aiwcli 0.15.5 → 0.15.7

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

@@ -0,0 +1,222 @@
+import path from 'node:path';
+import { checkVersionCompatibility, configureTmuxSession, detectMultiplexer, ensureLspPatch, findExecutable, findToolPath, getClaudeCodeVersion, launchTerminal, ProcessSpawnError, quoteForSh, readSentinelExitCode, spawnProcess, waitForSentinelFile, } from '../../../platform/launch.js';
+import { EXIT_CODES } from '../../../types/index.js';
+import { buildSpawnedWindowArgs, buildUniqueSessionName, parseExtraEnv, resolvePromptText, sanitizeSessionName, } from '../runtime-core/launch-options.js';
+function buildCodexArgs(platform) {
+    if (platform !== 'win32')
+        return ['--yolo'];
+    return ['-c', 'shell_type="bash"', '--yolo'];
+}
+function buildDevinArgs() {
+    return ['--permission-mode', 'dangerous'];
+}
+function toJsonLaunchResult(result, exitCode) {
+    return {
+        launched: result.launched,
+        backend: result.backend,
+        paneId: result.paneId ?? null,
+        sentinelPath: result.sentinelPath ?? null,
+        exitCode,
+        reason: result.reason ?? null,
+    };
+}
+async function resolveWaitExitCode(result, wait) {
+    if (!wait || !result.launched || !result.sentinelPath) {
+        return result.exitCode ?? null;
+    }
+    const finished = await waitForSentinelFile(result.sentinelPath, 14_400_000);
+    return finished ? readSentinelExitCode(result.sentinelPath, 1) : -1;
+}
+export async function executeLaunch(request, dependencies) {
+    const { cwd, flags, interactiveTty, platform, readPromptFile } = request;
+    const { host, now, pid, tempDir, writePromptFile } = dependencies;
+    delete process.env['CLAUDECODE'];
+    delete process.env['CLAUDE_CODE_ENTRYPOINT'];
+    const useCodex = flags.codex;
+    const useDevin = flags.devin;
+    if (platform === 'win32' && !useCodex && !useDevin) {
+        await ensureLspPatch({
+            debugLog: (message) => host.debug(message),
+            warn(message) {
+                host.warn(message);
+            },
+        });
+    }
+    const cliCommand = useDevin ? 'devin' : useCodex ? 'codex' : 'claude';
+    const cliArgs = useDevin ? buildDevinArgs() : useCodex ? buildCodexArgs(platform) : ['--dangerously-skip-permissions'];
+    const launchFlag = useDevin ? '--devin' : useCodex ? '--codex' : '';
+    const disableTmux = flags['no-tmux'];
+    const wantJson = flags.json;
+    const wantWait = flags.wait;
+    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);
+    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,
+            useDevin,
+            disableTmux,
+            ...(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;
+    }
+    if (useCodex) {
+        host.debug('Launching Codex with --yolo flag');
+    }
+    else if (useDevin) {
+        host.debug('Launching Devin with --permission-mode dangerous');
+    }
+    const [versionCheck, mux] = await Promise.all([
+        useCodex || useDevin
+            ? null
+            : getClaudeCodeVersion().then((v) => checkVersionCompatibility(v)),
+        disableTmux ? null : detectMultiplexer(platform),
+    ]);
+    if (versionCheck) {
+        host.debug(`Claude Code version: ${versionCheck.version ?? 'unknown'}`);
+        host.debug(`Compatibility status: ${versionCheck.compatible ? 'compatible' : 'incompatible'}`);
+        if (versionCheck.warning) {
+            host.warn(versionCheck.warning);
+        }
+    }
+    let exitCode = 0;
+    try {
+        if (!mux) {
+            if (disableTmux) {
+                host.logInfo('Multiplexer disabled via --no-tmux — launching inline');
+            }
+            else if (!interactiveTty) {
+                host.logInfo('Non-interactive terminal — launching inline');
+            }
+            else if (platform === 'win32') {
+                host.logInfo('No multiplexer found — launching inline. Install psmux for session management: winget install psmux');
+            }
+            else {
+                host.logInfo('No multiplexer found — launching inline. Install tmux for session management.');
+            }
+            exitCode = await spawnProcess(cliCommand, promptText ? [...cliArgs, promptText] : cliArgs);
+        }
+        else if (mux.isInsideSession()) {
+            host.logInfo(`Inside ${mux.backend} session — splitting new pane`);
+            if (mux.backend === 'tmux') {
+                configureTmuxSession();
+            }
+            let effectivePromptPath = promptPath;
+            if (!effectivePromptPath && promptText) {
+                effectivePromptPath = path.join(tempDir, `aiwcli-prompt-${now()}-${pid}.txt`);
+                writePromptFile(effectivePromptPath, promptText);
+            }
+            const splitResult = await mux.splitPane({
+                toolName: cliCommand,
+                args: cliArgs,
+                env: extraEnv,
+                cwd,
+                split: flags.split ?? 'auto',
+                promptPath: effectivePromptPath,
+                sentinel: wantWait || wantJson,
+            });
+            if (wantJson) {
+                const jsonExitCode = await resolveWaitExitCode(splitResult, wantWait);
+                host.log(JSON.stringify(toJsonLaunchResult(splitResult, jsonExitCode)));
+                host.exit(jsonExitCode ?? 0);
+            }
+            if (splitResult.launched) {
+                if (splitResult.paneId) {
+                    host.logInfo(`Launched in ${mux.backend} pane: ${splitResult.paneId}`);
+                }
+                else {
+                    host.logInfo(`Launched in ${mux.backend}`);
+                }
+                if (wantWait && splitResult.sentinelPath) {
+                    const waitedExitCode = await resolveWaitExitCode(splitResult, true);
+                    host.exit(waitedExitCode ?? 1);
+                }
+                return;
+            }
+            host.logWarning(`Pane split failed (${splitResult.reason}), launching directly`);
+            exitCode = await spawnProcess(cliCommand, promptText ? [...cliArgs, promptText] : cliArgs);
+        }
+        else {
+            const resolvedPath = mux.backend === 'psmux' ? findExecutable(cliCommand) : findToolPath(cliCommand);
+            if (resolvedPath) {
+                const sessionFromFlag = flags['tmux-session']?.trim();
+                const reattach = Boolean(sessionFromFlag && sessionFromFlag.length > 0);
+                const sessionName = reattach
+                    ? sanitizeSessionName(sessionFromFlag)
+                    : buildUniqueSessionName(`aiw-${path.basename(cwd)}`, now(), pid);
+                if (reattach) {
+                    host.logInfo(`Launching in ${mux.backend} session: ${sessionName} (reuse/attach)`);
+                }
+                else {
+                    host.logInfo(`Launching in new ${mux.backend} session: ${sessionName}`);
+                }
+                const result = await mux.createSession({
+                    sessionName,
+                    reattach,
+                    toolPath: resolvedPath,
+                    toolArgs: cliArgs,
+                    promptText,
+                });
+                if (result.usedMux) {
+                    exitCode = result.exitCode;
+                }
+                else {
+                    if (result.reason) {
+                        if (result.reason.includes('not found') || result.reason.includes('unavailable')) {
+                            host.logWarning(`${mux.backend} unavailable — launching inline. ${mux.backend === 'psmux' ? 'Install with: winget install psmux' : ''}`);
+                        }
+                        else if (result.reason.includes('too old')) {
+                            host.logWarning(`${result.reason} — launching inline. ${mux.backend === 'psmux' ? 'Update with: winget upgrade psmux' : ''}`);
+                        }
+                        else if (mux.backend === 'psmux' && result.reason.includes('attach failed')) {
+                            host.logWarning(`${result.reason} — launching inline. Recovery: run "psmux kill-server" and relaunch if this persists.`);
+                        }
+                        else {
+                            host.logWarning(`${result.reason} — launching inline`);
+                        }
+                    }
+                    exitCode = await spawnProcess(cliCommand, promptText ? [...cliArgs, promptText] : cliArgs);
+                }
+            }
+            else {
+                host.logWarning(`${cliCommand} not found on PATH (install from https://claude.ai/download)`);
+                exitCode = await spawnProcess(cliCommand, promptText ? [...cliArgs, promptText] : cliArgs);
+            }
+        }
+    }
+    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 });
+    }
+    host.exit(exitCode);
+}

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;
+}

package/dist/cli/base-command.js

@@ -0,0 +1,55 @@
+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';
+export default class BaseCommand extends Command {
+    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);
+        if (debugEnabled) {
+            debugVersion();
+        }
+    }
+    isQuiet() {
+        return isQuietMode();
+    }
+    logDebug(message) {
+        logDebug(message);
+    }
+    logError(message) {
+        logError(message);
+    }
+    logInfo(message) {
+        logInfo(message, this.isQuiet());
+    }
+    logSuccess(message) {
+        logSuccess(message, this.isQuiet());
+    }
+    logWarning(message) {
+        logWarning(message, this.isQuiet());
+    }
+    spinner(text) {
+        return createSpinner(text, { quiet: isQuietMode() });
+    }
+}

package/dist/commands/branch.d.ts

@@ -22,24 +22,4 @@ export default class BranchCommand extends BaseCommand {
         quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
-    /**
-     * Handle --delete flag: Delete git branch and worktree folder
-     */
-    private handleDelete;
-    /**
-     * Handle --delete --all flags: Clean up all worktrees safely
-     */
-    private handleDeleteAll;
-    /**
-     * Handle --main flag: Launch aiw in main/master branch
-     */
-    private handleMainBranch;
-    /**
-     * Handle --launch flag: Create or open worktree in sibling folder
-     */
-    private handleWorktreeLaunch;
-    /**
-     * Check if current directory is a git repository
-     */
-    private isGitRepository;
 }