aiwcli 0.15.5 → 0.15.7

package/dist/commands/launch.js

@@ -1,44 +1,66 @@
-import { execSync } from 'node:child_process';
-import { basename } from 'node:path';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import * as os from 'node:os';
 import { Flags } from '@oclif/core';
-import BaseCommand from '../lib/base-command.js';
-import { ProcessSpawnError } from '../lib/errors.js';
-import { spawnProcess } from '../lib/spawn.js';
-import { launchTerminal } from '../lib/terminal.js';
-import { checkVersionCompatibility, getClaudeCodeVersion } from '../lib/version.js';
-import { EXIT_CODES } from '../types/index.js';
+import { executeLaunch } from '../capabilities/launch/control-plane/execute-launch.js';
+import { buildUniqueSessionName, sanitizeSessionName } from '../capabilities/launch/runtime-core/launch-options.js';
+import BaseCommand from '../cli/base-command.js';
+import { quoteForSh, readSentinelExitCode, waitForSentinelFile } from '../platform/launch.js';
 /**
- * Launch Claude Code or Codex with AIW configuration.
+ * Launch Claude Code, Codex, or Devin with AIW configuration.
  *
  * Spawns Claude Code CLI with --dangerously-skip-permissions flag,
- * or Codex CLI with --yolo flag, enabling unattended execution.
- * Designed for AIW hook system safety guardrails (requires aiw setup).
- * Supports multiple parallel sessions.
+ * Codex CLI with --yolo flag, or Devin CLI with --permission-mode dangerous,
+ * enabling unattended execution. Supports multiple parallel sessions.
+ *
+ * ## Multiplexer-first launch (preferred)
+ *
+ * When a terminal multiplexer is available (psmux on Windows, tmux on Unix),
+ * the launch flow is:
+ *   - **Inside an existing session** → split a new pane in the current session
+ *   - **Outside any session** → create a new multiplexer session with the REPL
+ *
+ * This gives persistent sessions, pane splitting, and scrollback.
+ * Use `--no-tmux` to bypass the multiplexer and launch inline.
+ *
+ * ## Inline fallback
+ *
+ * When no multiplexer is available (or `--no-tmux` is set), the REPL launches
+ * directly in the current terminal.
+ *
+ * ## Install multiplexer
+ *   - Windows: `winget install psmux`  (native ConPTY multiplexer)
+ *   - Unix:    `apt install tmux` / `brew install tmux`
  */
 export default class LaunchCommand extends BaseCommand {
-    static description = 'Launch Claude Code or Codex with AIW configuration (sandbox disabled, tmux-first by default)\n\n' +
+    static description = 'Launch Claude Code, Codex, or Devin with AIW configuration (sandbox disabled, tmux-first; Windows opens mintty window first with inline fallback)\n\n' +
         'FLAGS\n' +
         '  --codex/-c: Launch Codex instead of Claude Code (uses --yolo flag)\n' +
+        '  --devin/-e: Launch Devin CLI instead of Claude Code (uses --permission-mode dangerous)\n' +
         '  --new/-n: Open a new terminal in the current directory and launch there\n' +
         '  --no-tmux/-t: Launch directly in current shell instead of auto-launching tmux\n' +
-        '  --tmux-session/-s: tmux session name to reuse when auto-launching tmux (default is fresh session per launch)\n\n' +
+        '  --tmux-session/-s: tmux session name to reuse when auto-launching tmux\n' +
+        '  --prompt/-p: Initial prompt to pass to the AI REPL at startup\n' +
+        '  --wait: Block until launched pane exits (for scripted callers)\n' +
+        '  --json: JSON output (paneId, backend, exitCode, sentinel)\n' +
+        '  --split: Split direction when in tmux (auto|h|v, default: auto)\n' +
+        '  --env: Extra env vars as JSON string\n' +
+        '  --prompt-path: Path to prompt file for REPL-mode tools\n\n' +
         'EXIT CODES\n' +
         '  0  Success - AI assistant launched and exited successfully\n' +
         '  1  General error - unexpected runtime failure\n' +
         '  2  Invalid usage - check your arguments and flags\n' +
-        '  3  Environment error - CLI not found (install Claude Code from https://claude.ai/download, Codex from npm)';
+        '  3  Environment error - CLI not found (install Claude Code from https://claude.ai/download, Codex from npm, Devin from https://cli.devin.ai)';
     static examples = [
         '<%= config.bin %> <%= command.id %>  # Auto-launches tmux with a fresh session when not already in tmux',
         '<%= config.bin %> <%= command.id %> --codex  # Launch Codex with --yolo flag',
-        '<%= config.bin %> <%= command.id %> -c  # Short form for --codex',
+        '<%= config.bin %> <%= command.id %> --devin  # Launch Devin CLI with --permission-mode dangerous',
         '<%= config.bin %> <%= command.id %> --new  # Launch in a new terminal window',
-        '<%= config.bin %> <%= command.id %> -n  # Short form for --new',
-        '<%= config.bin %> <%= command.id %> --codex --new  # Launch Codex in new terminal',
         '<%= config.bin %> <%= command.id %> --no-tmux  # Run directly in current shell',
         '<%= config.bin %> <%= command.id %> --tmux-session aiw-main  # Reuse/attach explicit tmux session name',
+        '<%= config.bin %> <%= command.id %> --prompt "Fix the login bug"  # Launch with initial prompt',
+        '<%= config.bin %> <%= command.id %> --wait --json  # Block until pane exits, output JSON result',
+        '<%= config.bin %> <%= command.id %> --split h  # Force horizontal split in tmux',
         '<%= config.bin %> <%= command.id %> --debug  # Enable verbose logging',
-        '# Check exit code in Bash\n<%= config.bin %> <%= command.id %>\necho $?',
-        '# Check exit code in PowerShell\n<%= config.bin %> <%= command.id %>\necho $LASTEXITCODE',
     ];
     static flags = {
         ...BaseCommand.baseFlags,
@@ -46,6 +68,21 @@ export default class LaunchCommand extends BaseCommand {
             char: 'c',
             description: 'Launch Codex instead of Claude Code (uses --yolo flag for full auto mode)',
             default: false,
+            exclusive: ['devin'],
+        }),
+        devin: Flags.boolean({
+            char: 'e',
+            description: 'Launch Devin CLI instead of Claude Code (uses --permission-mode dangerous)',
+            default: false,
+            exclusive: ['codex'],
+        }),
+        env: Flags.string({
+            description: 'Extra env vars as JSON object string (e.g. \'{"FOO":"bar"}\')',
+            required: false,
+        }),
+        json: Flags.boolean({
+            description: 'JSON output (paneId, backend, exitCode, sentinel)',
+            default: false,
         }),
         new: Flags.boolean({
             char: 'n',
@@ -57,159 +94,98 @@ export default class LaunchCommand extends BaseCommand {
             description: 'Launch directly in current shell instead of auto-launching tmux',
             default: false,
         }),
+        prompt: Flags.string({
+            char: 'p',
+            description: 'Initial prompt to pass to the AI REPL at startup',
+            required: false,
+        }),
+        'prompt-file': Flags.string({
+            description: 'Path to file containing initial prompt (internal)',
+            required: false,
+            hidden: true,
+        }),
+        'spawned-window': Flags.boolean({
+            description: 'Internal: marks launch as re-entered in a spawned terminal window',
+            required: false,
+            hidden: true,
+            default: false,
+        }),
+        'prompt-path': Flags.string({
+            description: 'Path to prompt file for REPL-mode tools',
+            required: false,
+        }),
+        split: Flags.string({
+            description: 'Split direction when in tmux (auto|h|v, default: auto)',
+            options: ['auto', 'h', 'v'],
+            required: false,
+        }),
         'tmux-session': Flags.string({
             char: 's',
             description: 'tmux session name to reuse when auto-launching tmux (default: new aiw-<current-dir>-<unique> session)',
             required: false,
         }),
+        wait: Flags.boolean({
+            description: 'Block until launched pane exits; output result',
+            default: false,
+        }),
     };
     async run() {
         const { flags } = await this.parse(LaunchCommand);
-        // Determine which CLI to launch
-        const useCodex = flags.codex;
-        const cliCommand = useCodex ? 'codex' : 'claude';
-        const cliArgs = useCodex ? ['--yolo'] : ['--dangerously-skip-permissions'];
-        const launchFlag = useCodex ? '--codex' : '';
-        const disableTmux = flags['no-tmux'];
-        const insideTmux = Boolean(process.env.TMUX);
-        const interactiveTty = Boolean(process.stdin.isTTY && process.stdout.isTTY);
-        const shouldAutoTmux = !flags.new && !disableTmux && !insideTmux && interactiveTty;
-        // Handle --new flag: launch in a new terminal
-        if (flags.new) {
-            const cwd = process.cwd();
-            this.debug(`Launching new terminal in: ${cwd}`);
-            const launchCmd = useCodex ? 'aiw launch --codex' : 'aiw launch';
-            const result = await launchTerminal({
-                cwd,
-                command: launchCmd,
-                debugLog: (msg) => this.debug(msg),
-            });
-            if (!result.success) {
-                this.error(`Failed to launch new terminal: ${result.error}`, { exit: EXIT_CODES.GENERAL_ERROR });
-            }
-            this.log(`New terminal launched with aiw launch${launchFlag ? ` ${launchFlag}` : ''}`);
-            return;
-        }
-        // Normal launch flow
-        let exitCode;
-        try {
-            // Version check only applies to Claude Code (not Codex)
-            if (useCodex) {
-                this.debug('Launching Codex with --yolo flag');
-            }
-            else {
-                // Check Claude Code version compatibility (non-blocking)
-                const version = await getClaudeCodeVersion();
-                const versionCheck = checkVersionCompatibility(version);
-                // Debug logging: show version information
-                this.debug(`Claude Code version: ${versionCheck.version ?? 'unknown'}`);
-                this.debug(`Compatibility status: ${versionCheck.compatible ? 'compatible' : 'incompatible'}`);
-                // Non-blocking warning for incompatibility or unknown version
-                if (versionCheck.warning) {
-                    this.warn(versionCheck.warning);
-                }
-            }
-            // Spawn AI CLI with sandbox permissions disabled
-            // AIW hook system provides safety guardrails
-            // Continue launch regardless of version check result (graceful degradation)
-            if (shouldAutoTmux && this.isTmuxAvailable()) {
-                const shellCommand = this.buildTmuxShellCommand(cliCommand, cliArgs);
-                const sessionFromFlag = flags['tmux-session']?.trim();
-                if (sessionFromFlag && sessionFromFlag.length > 0) {
-                    const sessionName = this.sanitizeTmuxSessionName(sessionFromFlag);
-                    this.logInfo(`Launching in tmux session: ${sessionName} (reuse/attach)`);
-                    exitCode = await spawnProcess('tmux', ['new-session', '-A', '-s', sessionName, shellCommand]);
-                }
-                else {
-                    const sessionBase = `aiw-${basename(process.cwd())}`;
-                    const sessionName = this.buildUniqueTmuxSessionName(sessionBase);
-                    this.logInfo(`Launching in new tmux session: ${sessionName}`);
-                    exitCode = await spawnProcess('tmux', ['new-session', '-s', sessionName, shellCommand]);
-                }
-            }
-            else if (shouldAutoTmux && this.isWindowsTerminalAvailable()) {
-                this.logInfo('tmux unavailable; launching in Windows Terminal split pane');
-                exitCode = await spawnProcess('wt', ['split-pane', '--', cliCommand, ...cliArgs]);
-            }
-            else {
-                if (shouldAutoTmux) {
-                    this.logInfo('No pane launcher available. Launching directly.');
-                }
-                else if (disableTmux) {
-                    this.debug('tmux launch disabled via --no-tmux');
-                }
-                else if (insideTmux) {
-                    this.debug('Already inside tmux; launching directly in current pane');
-                    this.enableTmuxMouseIfPossible();
-                }
-                else if (!interactiveTty) {
-                    this.debug('Non-interactive terminal detected; launching directly');
-                }
-                exitCode = await spawnProcess(cliCommand, cliArgs);
-            }
-        }
-        catch (error) {
-            if (error instanceof ProcessSpawnError) {
-                // Actionable error message (already includes installation link)
-                this.error(error.message, { exit: EXIT_CODES.ENVIRONMENT_ERROR });
-            }
-            // Unexpected error
-            this.error('Unexpected launch failure.', { exit: EXIT_CODES.GENERAL_ERROR });
-        }
-        // Pass through Claude Code's exit code (outside try-catch to avoid catching exit)
-        this.exit(exitCode);
+        await executeLaunch({
+            cwd: process.cwd(),
+            flags: flags,
+            interactiveTty: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+            platform: process.platform,
+            readPromptFile: (filePath) => (existsSync(filePath) ? readFileSync(filePath, 'utf8') : undefined),
+        }, {
+            host: {
+                debug: (message, ...args) => this.debug([message, ...args.map(String)].join(' ')),
+                error: (input, options) => this.error(input, options),
+                exit: (code) => this.exit(code),
+                log: (message) => this.log(message),
+                logInfo: (message) => this.logInfo(message),
+                logWarning: (message) => this.logWarning(message),
+                warn: (input) => this.warn(input),
+            },
+            now: () => Date.now(),
+            pid: process.pid,
+            tempDir: os.tmpdir(),
+            writePromptFile(filePath, content) {
+                writeFileSync(filePath, content, { encoding: 'utf8', mode: 0o600 });
+            },
+        });
     }
-    buildTmuxShellCommand(command, args) {
-        const launchCommand = [command, ...args].map((part) => this.shellQuote(part)).join(' ');
-        return `tmux set-option -g mouse on >/dev/null 2>&1 || true; exec ${launchCommand}`;
+    // Compatibility wrappers kept on the command prototype while launch
+    // orchestration now lives in the capability control-plane.
+    buildUniqueSessionName(base) {
+        return buildUniqueSessionName(base);
     }
-    isTmuxAvailable() {
-        try {
-            const cmd = process.platform === 'win32' ? 'where tmux' : 'which tmux';
-            execSync(cmd, { stdio: 'ignore' });
-            return true;
-        }
-        catch {
-            return false;
+    async handleJsonOutput(result, wait) {
+        let { exitCode } = result;
+        if (wait && result.launched && result.sentinelPath) {
+            const finished = await waitForSentinelFile(result.sentinelPath, 14_400_000);
+            exitCode = finished ? readSentinelExitCode(result.sentinelPath, 1) : -1;
         }
+        this.log(JSON.stringify({
+            launched: result.launched,
+            backend: result.backend,
+            paneId: result.paneId ?? null,
+            sentinelPath: result.sentinelPath ?? null,
+            exitCode: exitCode ?? null,
+            reason: result.reason ?? null,
+        }));
+        this.exit(exitCode ?? 0);
     }
-    isWindowsTerminalAvailable() {
-        if (process.platform !== 'win32')
-            return false;
-        try {
-            execSync('where wt', { stdio: 'ignore' });
-            return true;
-        }
-        catch {
-            return false;
-        }
+    sanitizeSessionName(input) {
+        return sanitizeSessionName(input);
     }
-    sanitizeTmuxSessionName(input) {
-        const trimmed = input.trim().toLowerCase();
-        const safe = trimmed
-            .replaceAll(/[^a-z0-9_-]/g, '-')
-            .replaceAll(/-+/g, '-')
-            .replaceAll(/^[-_]+|[-_]+$/g, '');
-        return safe || 'aiw';
-    }
-    buildUniqueTmuxSessionName(base) {
-        const safeBase = this.sanitizeTmuxSessionName(base);
-        const timestamp = Date.now().toString(36);
-        const pid = process.pid.toString(36);
-        return this.sanitizeTmuxSessionName(`${safeBase}-${timestamp}-${pid}`);
+    shellQuote(input) {
+        return quoteForSh(input);
     }
-    enableTmuxMouseIfPossible() {
-        if (!this.isTmuxAvailable())
+    async waitForSentinel(result) {
+        if (!result.sentinelPath)
             return;
-        try {
-            execSync('tmux set-option -g mouse on', { stdio: 'ignore' });
-            this.debug('Enabled tmux mouse support (set-option -g mouse on)');
-        }
-        catch {
-            this.debug('Could not enable tmux mouse support automatically');
-        }
-    }
-    shellQuote(input) {
-        return `'${input.replaceAll("'", `'"'"'`)}'`;
+        const finished = await waitForSentinelFile(result.sentinelPath, 14_400_000);
+        this.exit(finished ? readSentinelExitCode(result.sentinelPath, 1) : 1);
     }
 }

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

@@ -1,114 +1 @@
-import { Command } from '@oclif/core';
-import { type Ora } from 'ora';
-/**
- * Base command class that all AI Workflow CLI commands should extend.
- * Provides global --debug flag support for verbose logging.
- *
- * @example Basic command with debug support
- * import {debug} from '../lib/debug.js'
- *
- * export default class MyCommand extends BaseCommand {
- *   static override flags = {
- *     ...BaseCommand.baseFlags,
- *     // command-specific flags
- *   }
- *
- *   async run() {
- *     // debug mode is already enabled if --debug flag was passed
- *     // version info is automatically logged when debug enabled
- *     debug('My debug message')
- *   }
- * }
- *
- * @example Command with spinner progress feedback
- * import {ux} from '@oclif/core'
- *
- * export default class LongCommand extends BaseCommand {
- *   async run() {
- *     // Check if output is piped (suppress spinners for piped output)
- *     const isPiped = !process.stdout.isTTY
- *
- *     if (!isPiped) {
- *       // Show spinner for long operations in interactive terminal
- *       ux.action.start('Processing')
- *       await longRunningOperation()
- *       ux.action.stop()
- *     } else {
- *       // Piped output - suppress spinner
- *       await longRunningOperation()
- *     }
- *   }
- * }
- *
- * @example Spinner with status updates
- * import {ux} from '@oclif/core'
- *
- * export default class MultiStepCommand extends BaseCommand {
- *   async run() {
- *     if (process.stdout.isTTY) {
- *       ux.action.start('Installing packages')
- *       await installPackages()
- *
- *       // Update spinner status
- *       ux.action.status = 'Configuring'
- *       await configure()
- *
- *       ux.action.stop('Done!')
- *     } else {
- *       await installPackages()
- *       await configure()
- *     }
- *   }
- * }
- */
-export default abstract class BaseCommand extends Command {
-    /**
-     * Global flags inherited by all AI Workflow CLI commands.
-     * All command classes should spread these flags into their own flag definitions:
-     * `static override flags = { ...BaseCommand.baseFlags, /* command-specific flags *\/ }`
-     *
-     * @see Command Development Guide in README.md for usage patterns
-     */
-    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>;
-    /**
-     * Check if quiet mode is enabled.
-     * Returns true if --quiet/-q flag was passed.
-     */
-    protected isQuiet(): boolean;
-    /**
-     * Log debug message (stdout, dim in TTY).
-     * Debug output is independent of quiet mode.
-     */
-    protected logDebug(message: string): void;
-    /**
-     * Log error message (stderr, red in TTY).
-     * Errors are NEVER suppressed, even in quiet mode.
-     */
-    protected logError(message: string): void;
-    /**
-     * Log informational message (stdout, no color).
-     * Suppressed in quiet mode.
-     */
-    protected logInfo(message: string): void;
-    /**
-     * Log success message (stdout, green in TTY).
-     * Suppressed in quiet mode.
-     */
-    protected logSuccess(message: string): void;
-    /**
-     * Log warning message (stdout, yellow in TTY).
-     * Suppressed in quiet mode.
-     */
-    protected logWarning(message: string): void;
-    abstract run(): Promise<void>;
-    /**
-     * Create a TTY-aware spinner for long-running operations.
-     * Automatically disabled when output is piped, in CI environments, or in quiet mode.
-     */
-    protected spinner(text: string): Ora;
-}
+export { default } from '../cli/base-command.js';

package/dist/lib/base-command.js

@@ -1,153 +1 @@
-import { Command, Flags } from '@oclif/core';
-import { debugVersion, setDebugEnabled } from '../lib/debug.js';
-import { logDebug, logError, logInfo, logSuccess, logWarning } from '../lib/output.js';
-import { isQuietMode, setQuietMode } from '../lib/quiet.js';
-import { createSpinner } from '../lib/spinner.js';
-/**
- * Base command class that all AI Workflow CLI commands should extend.
- * Provides global --debug flag support for verbose logging.
- *
- * @example Basic command with debug support
- * import {debug} from '../lib/debug.js'
- *
- * export default class MyCommand extends BaseCommand {
- *   static override flags = {
- *     ...BaseCommand.baseFlags,
- *     // command-specific flags
- *   }
- *
- *   async run() {
- *     // debug mode is already enabled if --debug flag was passed
- *     // version info is automatically logged when debug enabled
- *     debug('My debug message')
- *   }
- * }
- *
- * @example Command with spinner progress feedback
- * import {ux} from '@oclif/core'
- *
- * export default class LongCommand extends BaseCommand {
- *   async run() {
- *     // Check if output is piped (suppress spinners for piped output)
- *     const isPiped = !process.stdout.isTTY
- *
- *     if (!isPiped) {
- *       // Show spinner for long operations in interactive terminal
- *       ux.action.start('Processing')
- *       await longRunningOperation()
- *       ux.action.stop()
- *     } else {
- *       // Piped output - suppress spinner
- *       await longRunningOperation()
- *     }
- *   }
- * }
- *
- * @example Spinner with status updates
- * import {ux} from '@oclif/core'
- *
- * export default class MultiStepCommand extends BaseCommand {
- *   async run() {
- *     if (process.stdout.isTTY) {
- *       ux.action.start('Installing packages')
- *       await installPackages()
- *
- *       // Update spinner status
- *       ux.action.status = 'Configuring'
- *       await configure()
- *
- *       ux.action.stop('Done!')
- *     } else {
- *       await installPackages()
- *       await configure()
- *     }
- *   }
- * }
- */
-export default class BaseCommand extends Command {
-    /**
-     * Global flags inherited by all AI Workflow CLI commands.
-     * All command classes should spread these flags into their own flag definitions:
-     * `static override flags = { ...BaseCommand.baseFlags, /* command-specific flags *\/ }`
-     *
-     * @see Command Development Guide in README.md for usage patterns
-     */
-    static baseFlags = {
-        debug: Flags.boolean({
-            char: 'd',
-            description: 'Enable verbose debug logging',
-            default: false,
-        }),
-        help: Flags.help({
-            char: 'h',
-            description: 'Show help for command',
-        }),
-        quiet: Flags.boolean({
-            char: 'q',
-            description: 'Suppress informational output (errors still shown)',
-            default: false,
-        }),
-    };
-    async init() {
-        await super.init();
-        const { flags } = await this.parse(this.constructor);
-        const debugEnabled = flags.debug ?? false;
-        const quietEnabled = flags.quiet ?? false;
-        setDebugEnabled(debugEnabled);
-        setQuietMode(quietEnabled);
-        // Automatically show version info in debug mode (AC4, FR24)
-        if (debugEnabled) {
-            debugVersion();
-        }
-    }
-    /**
-     * Check if quiet mode is enabled.
-     * Returns true if --quiet/-q flag was passed.
-     */
-    isQuiet() {
-        // Access via module-level state (set in init())
-        return isQuietMode();
-    }
-    /**
-     * Log debug message (stdout, dim in TTY).
-     * Debug output is independent of quiet mode.
-     */
-    logDebug(message) {
-        logDebug(message);
-    }
-    /**
-     * Log error message (stderr, red in TTY).
-     * Errors are NEVER suppressed, even in quiet mode.
-     */
-    logError(message) {
-        logError(message);
-    }
-    /**
-     * Log informational message (stdout, no color).
-     * Suppressed in quiet mode.
-     */
-    logInfo(message) {
-        logInfo(message, this.isQuiet());
-    }
-    /**
-     * Log success message (stdout, green in TTY).
-     * Suppressed in quiet mode.
-     */
-    logSuccess(message) {
-        logSuccess(message, this.isQuiet());
-    }
-    /**
-     * Log warning message (stdout, yellow in TTY).
-     * Suppressed in quiet mode.
-     */
-    logWarning(message) {
-        logWarning(message, this.isQuiet());
-    }
-    /**
-     * Create a TTY-aware spinner for long-running operations.
-     * Automatically disabled when output is piped, in CI environments, or in quiet mode.
-     */
-    spinner(text) {
-        return createSpinner(text, { quiet: isQuietMode() });
-    }
-}
+export { default } from '../cli/base-command.js';