aiwcli 0.15.5 → 0.15.7

package/dist/templates/_shared/lib-ts/base/subprocess-utils.ts

@@ -1,249 +0,0 @@
-/**
- * Subprocess environment utilities.
- * See SPEC.md §5.10
- */
-
-import { execSync, execFile } from "node:child_process";
-import type { ChildProcess, ExecSyncOptionsWithStringEncoding } from "node:child_process";
-
-// ─── Child Process Cleanup ─────────────────────────────────────────────────
-//
-// Track all spawned child processes to prevent orphaned Node.js processes.
-//
-// Problem: When parent process exits (Ctrl+C, abnormal termination), child
-// processes spawned via execFile can become orphaned if they haven't completed.
-//
-// Solution: Track children in a Set, register exit/signal handlers to kill all
-// tracked children before parent exits.
-//
-// Windows behavior: On Windows with shell:true, execFile spawns cmd.exe which
-// spawns the actual node.exe. Using SIGKILL ensures both are terminated.
-
-const childProcesses = new Set<ChildProcess>();
-
-/**
- * Cleanup all tracked child processes.
- * Called by exit and signal handlers.
- */
-function cleanupChildren(): void {
-  for (const child of childProcesses) {
-    try {
-      // Use SIGKILL for forceful termination (important on Windows with shell)
-      child.kill("SIGKILL");
-    } catch {
-      // Ignore errors (child may have already exited)
-    }
-  }
-  childProcesses.clear();
-}
-
-// Register exit handler (runs when process exits normally)
-process.on("exit", () => {
-  cleanupChildren();
-});
-
-// Register signal handlers (Ctrl+C, kill command)
-process.on("SIGINT", () => {
-  cleanupChildren();
-  process.exit(130); // Standard exit code for SIGINT
-});
-
-process.on("SIGTERM", () => {
-  cleanupChildren();
-  process.exit(143); // Standard exit code for SIGTERM
-});
-
-/**
- * Check if this is an internal subprocess call.
- * All hooks should check this and return early to prevent recursion.
- */
-export function isInternalCall(): boolean {
-  return process.env.AIWCLI_INTERNAL_CALL === "true";
-}
-
-/**
- * Get environment for internal subprocess calls.
- * Returns a copy of process.env with AIWCLI_INTERNAL_CALL=true and
- * Claude Code nesting-detection env vars removed so subprocess
- * claude instances can run without being blocked.
- */
-export function getInternalSubprocessEnv(): Record<string, string | undefined> {
-  const env: Record<string, string | undefined> = {
-    ...process.env,
-    AIWCLI_INTERNAL_CALL: "true",
-  };
-  // Explicitly delete vars that block subprocess calls (set to undefined does not work)
-  delete env.CLAUDECODE;
-  delete env.CLAUDE_CODE_ENTRYPOINT;
-  return env;
-}
-/**
- * Find an executable on the system PATH.
- * Uses `where` on Windows, `which` on Unix.
- * On Windows, prefers .cmd/.exe over extensionless shims since
- * execFileSync cannot spawn extensionless shell scripts.
- * Returns the first match or null if not found.
- */
-export function findExecutable(name: string): string | null {
-  try {
-    const cmd = process.platform === "win32" ? `where ${name}` : `which ${name}`;
-    // shell: true is valid at runtime but Node's TS types restrict it to string for this overload
-    const lines = execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], shell: true } as unknown as ExecSyncOptionsWithStringEncoding)
-      .trim()
-      .split(/\r?\n/)
-      .map((l) => l.trim())
-      .filter(Boolean);
-
-    if (lines.length === 0) return null;
-
-    // On Windows, `where` may return an extensionless shim first (e.g. npm creates
-    // both `claude` and `claude.cmd`). execFileSync can't spawn the extensionless
-    // one, so prefer .cmd or .exe.
-    if (process.platform === "win32") {
-      const preferred = lines.find((l) => /\.(cmd|exe)$/i.test(l));
-      return preferred ?? lines[0] ?? null;
-    }
-
-    return lines[0] ?? null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Type guard for Node.js child_process exec errors.
- * ExecSync throws objects with these extra properties on non-zero exit or timeout.
- */
-export interface ExecSyncError {
-  killed: boolean;
-  signal: string | null;
-  stdout: Buffer | string;
-  stderr: Buffer | string;
-  status: number | null;
-  message: string;
-}
-
-/** Check if an unknown error is an ExecSync error with process info. */
-export function isExecSyncError(e: unknown): e is ExecSyncError {
-  return (
-    typeof e === "object" &&
-    e !== null &&
-    "killed" in e &&
-    "signal" in e
-  );
-}
-
-/**
- * Quote a string for use as a cmd.exe argument when shell: true.
- * Wraps in double quotes and escapes inner double quotes as "".
- * On non-Windows platforms, returns the string unchanged (execFile
- * handles quoting automatically without shell).
- */
-/**
- * Normalize a file path for CLI subprocess usage.
- * Replaces backslashes with forward slashes on Windows to avoid
- * cmd.exe escape interpretation issues. No-op on other platforms.
- * Forward slashes are valid path separators on Windows in all modern CLIs.
- */
-export function normalizePathForCli(p: string): string {
-  if (process.platform !== "win32") return p;
-  return p.replaceAll("\\", "/");
-}
-
-export function shellQuoteWin(arg: string): string {
-  if (process.platform !== "win32") return arg;
-  return '"' + arg.replaceAll('"', '""') + '"';
-}
-
-// ---------------------------------------------------------------------------
-// Async Subprocess Execution
-// ---------------------------------------------------------------------------
-
-/**
- * Result from an async subprocess execution.
- * Never throws — callers inspect fields to determine outcome.
- */
-export interface ExecResult {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-  killed: boolean;
-  signal: string | null;
-}
-
-/** Options for execFileAsync. */
-export interface ExecAsyncOptions {
-  /** Data piped to the child's stdin. */
-  input?: string;
-  /** Timeout in milliseconds (not seconds). */
-  timeout?: number;
-  /** Environment variables for the child process. */
-  env?: Record<string, string | undefined>;
-  /** Maximum bytes on stdout/stderr. Default: 10 MB. */
-  maxBuffer?: number;
-  /** Use shell for execution. Required on Windows for .cmd files. */
-  shell?: boolean;
-}
-
-/**
- * Async subprocess execution that does NOT block the event loop.
- * Drop-in replacement for execFileSync in Promise-based parallel patterns.
- *
- * Returns ExecResult on both success and non-zero exit.
- * On timeout: result.killed = true, result.signal = "SIGTERM".
- * On spawn failure: result.exitCode = -1, result.stderr contains error.
- */
-export function execFileAsync(
-  file: string,
-  args: string[],
-  options?: ExecAsyncOptions,
-): Promise<ExecResult> {
-  return new Promise((resolve) => {
-    const child = execFile(
-      file,
-      args,
-      {
-        encoding: "utf-8",
-        timeout: options?.timeout ?? 0,
-        env: options?.env as NodeJS.ProcessEnv,
-        maxBuffer: options?.maxBuffer ?? 10 * 1024 * 1024,
-        shell: options?.shell,
-      },
-      (error, stdout, stderr) => {
-        if (error) {
-          // execFile callback error includes process exit info
-          const errObj = error as unknown as Record<string, unknown>;
-          resolve({
-            stdout: String(stdout ?? ""),
-            stderr: String(stderr ?? ""),
-            exitCode: typeof errObj.code === "number" ? errObj.code : (error as any).status ?? 1,
-            killed: Boolean(errObj.killed),
-            signal: typeof errObj.signal === "string" ? errObj.signal : null,
-          });
-        } else {
-          resolve({
-            stdout: String(stdout ?? ""),
-            stderr: String(stderr ?? ""),
-            exitCode: 0,
-            killed: false,
-            signal: null,
-          });
-        }
-      },
-    );
-
-    // Track child process for cleanup on abnormal parent exit
-    childProcesses.add(child);
-
-    // Remove from tracking when child exits (normal completion)
-    child.on("exit", () => {
-      childProcesses.delete(child);
-    });
-
-    // Pipe input to stdin if provided
-    if (options?.input !== null && options?.input !== undefined && child.stdin) {
-      child.stdin.write(options.input);
-      child.stdin.end();
-    }
-  });
-}

package/dist/templates/_shared/lib-ts/base/tmux-driver.ts

@@ -1,341 +0,0 @@
-/**
- * Shared pane driver helpers for launching CLI tools in visible panes.
- *
- * This module now delegates pane creation to platform-specific launchers:
- * - tmux (Linux/macOS in tmux sessions)
- * - Windows Terminal split-pane
- * - Windows new-window fallback
- *
- * Prompt delivery is handled at launch time by passing prompt text as a CLI
- * argument for REPL mode, rather than injecting into an already-running pane.
- */
-
-import * as fs from "node:fs";
-
-import { createPaneLauncher, type PaneBackend, type PaneSplitDirection } from "./pane-launcher.js";
-import { cleanupSentinelIpc, createSentinelIpcPaths } from "./sentinel-ipc.js";
-import { execFileAsync, findExecutable } from "./subprocess-utils.js";
-import {
-  getTmuxAvailability,
-  normalizeSplitFlag,
-  quoteForSh,
-  type TmuxAvailability,
-  type TmuxSplitFlag,
-} from "./launchers/tmux-launcher.js";
-
-export type { TmuxAvailability, TmuxSplitFlag };
-export { getTmuxAvailability, normalizeSplitFlag, quoteForSh };
-
-export type DriverMode = "exec" | "repl";
-export type TmuxSplitOption = TmuxSplitFlag | "auto";
-
-export interface DriverPreflightResult {
-  available: boolean;
-  error?: string;
-}
-
-export type DriverPreflight =
-  (toolPath: string) => Promise<DriverPreflightResult> | DriverPreflightResult;
-
-export interface LaunchDriverOptions {
-  toolName: string;
-  toolBin?: string;
-  mode?: DriverMode;
-  args?: string[];
-  env?: Record<string, string>;
-  promptPath?: string;
-  splitFlag?: TmuxSplitOption;
-  splitTarget?: string;
-  autoClose?: boolean;
-  holdPane?: boolean;
-  holdMessage?: string;
-  allowExecFallback?: boolean;
-  preflight?: DriverPreflight;
-  timeoutMs?: number;
-}
-
-export interface LaunchDriverResult {
-  launched: boolean;
-  usedTmux: boolean;
-  backend: PaneBackend;
-  mode: DriverMode;
-  toolPath?: string;
-  paneId?: string;
-  sentinelPath?: string;
-  exitCode?: number;
-  stdout?: string;
-  reason?: string;
-  stderr?: string;
-}
-
-function buildEnvPrefix(env: Record<string, string>): string {
-  return Object.entries(env)
-    .map(([key, value]) => `${key}=${quoteForSh(value)}`)
-    .join(" ");
-}
-
-function quoteForPowerShell(input: string): string {
-  return `'${input.replaceAll("'", "''")}'`;
-}
-
-function buildCommandArgs(
-  args: string[],
-  mode: DriverMode,
-  promptPath?: string,
-): string[] {
-  if (mode !== "repl" || !promptPath) return args;
-  const promptText = fs.readFileSync(promptPath, "utf-8");
-  return [...args, promptText];
-}
-
-function buildShToolCommand(
-  toolPath: string,
-  args: string[],
-  env: Record<string, string>,
-  mode: DriverMode,
-  promptPath?: string,
-): string {
-  const envPrefix = buildEnvPrefix(env);
-  const commandArgs = buildCommandArgs(args, mode, promptPath);
-  const argPart = commandArgs.map((arg) => quoteForSh(arg)).join(" ");
-  const base = [envPrefix, quoteForSh(toolPath), argPart]
-    .filter(Boolean)
-    .join(" ");
-
-  if (mode === "exec" && promptPath) {
-    return `${base} < ${quoteForSh(promptPath)}`;
-  }
-
-  return base;
-}
-
-function buildPowerShellToolCommand(
-  toolPath: string,
-  args: string[],
-  env: Record<string, string>,
-  mode: DriverMode,
-  promptPath?: string,
-): string {
-  const envPrefix = Object.entries(env)
-    .map(([key, value]) => `$env:${key}=${quoteForPowerShell(value)}`)
-    .join("; ");
-
-  const commandArgs = buildCommandArgs(args, mode, promptPath);
-  const argArray = commandArgs.map((arg) => quoteForPowerShell(arg)).join(", ");
-  const invocation = `& ${quoteForPowerShell(toolPath)}${argArray ? ` @(${argArray})` : ""}`;
-
-  const body = mode === "exec" && promptPath
-    ? `Get-Content -Raw -Path ${quoteForPowerShell(promptPath)} | ${invocation}`
-    : invocation;
-
-  return [envPrefix, body].filter(Boolean).join("; ");
-}
-
-function wrapPaneCommand(
-  backend: PaneBackend,
-  command: string,
-  sentinelPath: string,
-  autoClose: boolean,
-  holdPane: boolean,
-  holdMessage: string,
-): string {
-  if (backend === "tmux") {
-    const base = `${command}; code=$?; printf '%s' "$code" > ${quoteForSh(sentinelPath)}`;
-
-    if (autoClose) {
-      return `${base}; tmux kill-pane -t "$TMUX_PANE" >/dev/null 2>&1 || true; exit $code`;
-    }
-
-    if (holdPane) {
-      return `${base}; echo; echo ${quoteForSh(holdMessage)}; exec bash`;
-    }
-
-    return `${base}; exit $code`;
-  }
-
-  const base = `${command}; $code = $LASTEXITCODE; Set-Content -Path ${quoteForPowerShell(sentinelPath)} -Value $code -NoNewline`;
-
-  if (holdPane && !autoClose) {
-    return `${base}; Write-Host ''; Write-Host ${quoteForPowerShell(holdMessage)}; Read-Host -Prompt 'Press Enter to close' | Out-Null`;
-  }
-
-  return `${base}; exit $code`;
-}
-
-function mapSplitDirection(splitFlag: TmuxSplitOption | undefined): PaneSplitDirection {
-  if (splitFlag === "auto") return "auto";
-  if (splitFlag === "-v") return "v";
-  return "h";
-}
-
-export function isTruthy(value: string | undefined): boolean {
-  if (!value) return false;
-  const normalized = value.trim().toLowerCase();
-  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
-}
-
-export function resolveToolPath(toolName: string, toolBin?: string): string | null {
-  const bin = toolBin?.trim() || toolName;
-  return findExecutable(bin);
-}
-
-function buildCommandForBackend(
-  backend: PaneBackend,
-  toolPath: string,
-  args: string[],
-  envVars: Record<string, string>,
-  mode: DriverMode,
-  promptPath?: string,
-): string {
-  if (backend === "tmux") {
-    return buildShToolCommand(toolPath, args, envVars, mode, promptPath);
-  }
-
-  return buildPowerShellToolCommand(toolPath, args, envVars, mode, promptPath);
-}
-
-export async function launchDriverInTmuxOrFallback(
-  options: LaunchDriverOptions,
-): Promise<LaunchDriverResult> {
-  const mode = options.mode ?? "exec";
-  const args = options.args ?? [];
-  const envVars = options.env ?? {};
-  const timeoutMs = options.timeoutMs ?? 0;
-  const toolPath = resolveToolPath(options.toolName, options.toolBin);
-
-  if (!toolPath) {
-    return {
-      launched: false,
-      usedTmux: false,
-      backend: "exec",
-      mode,
-      reason: `${options.toolBin ?? options.toolName} not found on PATH`,
-    };
-  }
-
-  if (options.preflight) {
-    const preflight = await options.preflight(toolPath);
-    if (!preflight.available) {
-      return {
-        launched: false,
-        usedTmux: false,
-        backend: "exec",
-        mode,
-        toolPath,
-        reason: preflight.error ?? "driver preflight failed",
-      };
-    }
-  }
-
-  if (options.promptPath && !fs.existsSync(options.promptPath)) {
-    return {
-      launched: false,
-      usedTmux: false,
-      backend: "exec",
-      mode,
-      toolPath,
-      reason: `prompt file not found: ${options.promptPath}`,
-    };
-  }
-
-  const paneLauncher = await createPaneLauncher({ requireTmuxSession: true });
-  if (paneLauncher) {
-    const sentinel = createSentinelIpcPaths(`aiwcli-pane-${options.toolName}`);
-
-    try {
-      const baseCommand = buildCommandForBackend(
-        paneLauncher.backend,
-        toolPath,
-        args,
-        envVars,
-        mode,
-        options.promptPath,
-      );
-
-      const holdMessage = options.holdMessage ?? "[aiwcli] Driver exited. Pane held open.";
-      const paneCommand = wrapPaneCommand(
-        paneLauncher.backend,
-        baseCommand,
-        sentinel.sentinelPath,
-        Boolean(options.autoClose),
-        Boolean(options.holdPane) && !Boolean(options.autoClose),
-        holdMessage,
-      );
-
-      const paneResult = await paneLauncher.launch({
-        command: paneCommand,
-        splitDirection: mapSplitDirection(options.splitFlag),
-        splitTarget: options.splitTarget,
-      });
-
-      if (!paneResult.launched) {
-        cleanupSentinelIpc(sentinel);
-        return {
-          launched: false,
-          usedTmux: paneLauncher.backend === "tmux",
-          backend: paneLauncher.backend,
-          mode,
-          toolPath,
-          reason: paneResult.reason ?? "pane launch failed",
-          stderr: paneResult.stderr,
-        };
-      }
-
-      return {
-        launched: true,
-        usedTmux: paneLauncher.backend === "tmux",
-        backend: paneLauncher.backend,
-        mode,
-        toolPath,
-        paneId: paneResult.paneId,
-        sentinelPath: sentinel.sentinelPath,
-      };
-    } catch (error) {
-      cleanupSentinelIpc(sentinel);
-      return {
-        launched: false,
-        usedTmux: paneLauncher.backend === "tmux",
-        backend: paneLauncher.backend,
-        mode,
-        toolPath,
-        reason: `pane launch failed: ${String(error)}`,
-      };
-    }
-  }
-
-  if (options.allowExecFallback) {
-    const commandArgs = buildCommandArgs(args, mode, options.promptPath);
-    const input = mode === "exec" && options.promptPath
-      ? fs.readFileSync(options.promptPath, "utf-8")
-      : undefined;
-
-    const result = await execFileAsync(toolPath, commandArgs, {
-      input,
-      timeout: timeoutMs,
-      env: { ...process.env, ...envVars },
-      shell: process.platform === "win32",
-    });
-
-    return {
-      launched: true,
-      usedTmux: false,
-      backend: "exec",
-      mode,
-      toolPath,
-      exitCode: result.exitCode,
-      stdout: result.stdout,
-      stderr: result.stderr,
-      reason: result.exitCode === 0 ? undefined : `fallback exec exited ${result.exitCode}`,
-    };
-  }
-
-  const tmux = getTmuxAvailability({ requireSessionEnv: true });
-  return {
-    launched: false,
-    usedTmux: false,
-    backend: "exec",
-    mode,
-    toolPath,
-    reason: `${tmux.reason ?? "no available pane launcher"}; fallback disabled`,
-  };
-}

package/dist/templates/_shared/lib-ts/base/tmux-pane-placement.ts

@@ -1,78 +0,0 @@
-import { execFileAsync } from "./subprocess-utils.js";
-
-export type TmuxSplitFlag = "-h" | "-v";
-
-export interface TmuxPaneInfo {
-  paneId: string;
-  width: number;
-  height: number;
-  active: boolean;
-}
-
-export interface PlacementResult {
-  targetPane: string;
-  splitFlag: TmuxSplitFlag;
-}
-
-const LIST_PANES_FORMAT = "#{pane_id} #{pane_width} #{pane_height} #{pane_active}";
-
-export async function listPanes(tmuxPath: string): Promise<TmuxPaneInfo[]> {
-  const result = await execFileAsync(tmuxPath, ["list-panes", "-F", LIST_PANES_FORMAT], {
-    timeout: 3000,
-  });
-  if (result.exitCode !== 0) return [];
-
-  const panes: TmuxPaneInfo[] = [];
-  for (const rawLine of result.stdout.split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (!line) continue;
-
-    const parts = line.split(/\s+/);
-    if (parts.length < 4) continue;
-
-    const paneId = parts[0] ?? "";
-    const width = Number.parseInt(parts[1] ?? "", 10);
-    const height = Number.parseInt(parts[2] ?? "", 10);
-    const activeRaw = parts[3] ?? "";
-
-    if (!paneId || !Number.isFinite(width) || !Number.isFinite(height)) continue;
-    panes.push({
-      paneId,
-      width,
-      height,
-      active: activeRaw === "1",
-    });
-  }
-
-  return panes;
-}
-
-export function findBestSplit(panes: TmuxPaneInfo[]): PlacementResult | null {
-  if (panes.length === 0) return null;
-
-  let best = panes[0];
-  let bestArea = best.width * best.height;
-
-  for (let i = 1; i < panes.length; i++) {
-    const pane = panes[i];
-    if (!pane) continue;
-    const area = pane.width * pane.height;
-    if (area > bestArea) {
-      best = pane;
-      bestArea = area;
-    }
-  }
-
-  // Terminal cells are ~2x taller than wide (typical monospace font aspect ratio).
-  // Correct for this so BSP splits the visually longer axis, not just the higher
-  // character count. Without this, a 77x68 pane looks "wider" in chars but is
-  // actually much taller in pixels, and should split top/bottom (-v), not left/right.
-  const CELL_ASPECT_RATIO = 2.0;
-  const visualWidth = best.width;
-  const visualHeight = best.height * CELL_ASPECT_RATIO;
-
-  return {
-    targetPane: best.paneId,
-    splitFlag: visualWidth >= visualHeight ? "-h" : "-v",
-  };
-}

package/dist/templates/_shared/lib-ts/package.json

@@ -1,20 +0,0 @@
-{
-  "name": "lib-ts-tests",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "test": "mocha",
-    "test:unit": "mocha '__tests__/base/**/*.test.ts' '__tests__/templates/**/*.test.ts'",
-    "test:contract": "mocha '__tests__/context/**/*.test.ts' '__tests__/handoff/**/*.test.ts'",
-    "test:integration": "mocha '__tests__/integration/**/*.test.ts'",
-    "test:parity": "mocha '__tests__/integration/python-parity.test.ts'"
-  },
-  "devDependencies": {
-    "mocha": "^10.0.0",
-    "chai": "^5.0.0",
-    "@types/mocha": "^10.0.0",
-    "@types/sinon": "^17.0.0",
-    "sinon": "^17.0.0",
-    "typescript": "^5.0.0"
-  }
-}