aiwcli 0.15.7 → 0.17.0

package/dist/templates/core/lib-ts/agent-exec/backends/tmux.ts

@@ -1,148 +0,0 @@
-/**
- * Tmux execution backend — runs CLI agents in visible tmux panes
- * with sentinel-file-based output capture.
- *
- * Self-contained tmux interaction — does not depend on tmux-driver.ts
- * or the pane launcher stack (those are consolidated into the `aiw` CLI).
- */
-
-import * as fs from "node:fs";
-import path from "node:path";
-
-import {
-  buildShellCaptureScript,
-  cleanupSentinelIpc,
-  createSentinelIpcPaths,
-  readSentinelExitCode,
-  readTextIfExists,
-  waitForSentinelFile,
-} from "../../runtime/sentinel-ipc.js";
-import { execFileAsync, findExecutable } from "../../runtime/subprocess-utils.js";
-import { findPsmux } from "../../runtime/tmux-preflight.js";
-import type { ExecutionBackend, ExecutionRequest, ExecutionResult } from "../execution-backend.js";
-
-export interface TmuxBackendOptions {
-  splitFlag?: string;
-  splitTarget?: string;
-}
-
-function quoteForSh(input: string): string {
-  return `'${input.replaceAll("'", "'\"'\"'")}'`;
-}
-
-function normalizeSplitFlag(value: string | undefined): "-h" | "-v" {
-  return value?.trim() === "-v" ? "-v" : "-h";
-}
-
-export class TmuxBackend implements ExecutionBackend {
-  private options: TmuxBackendOptions;
-
-  constructor(options?: TmuxBackendOptions) {
-    this.options = options ?? {};
-  }
-
-  async execute(request: ExecutionRequest): Promise<ExecutionResult> {
-    // On Windows, use psmux (native ConPTY multiplexer) instead of tmux
-    const isWindows = process.platform === "win32";
-    const muxBinary = isWindows ? "psmux" : "tmux";
-
-    if (!isWindows && !process.env.TMUX) {
-      return {
-        stdout: "",
-        stderr: "tmux pane launch failed: TMUX is not set",
-        exitCode: 1,
-        killed: false,
-        signal: null,
-      };
-    }
-
-    const tmuxPath = isWindows ? findPsmux() : findExecutable("tmux");
-    if (!tmuxPath) {
-      return {
-        stdout: "",
-        stderr: `${muxBinary} pane launch failed: ${muxBinary} not found on PATH`,
-        exitCode: 1,
-        killed: false,
-        signal: null,
-      };
-    }
-
-    const agentName = path.basename(request.cliPath).replace(/\.[^.]+$/, "");
-    const ipc = createSentinelIpcPaths(`aiwcli-agent-${agentName}`);
-
-    try {
-      fs.writeFileSync(ipc.inputPath, request.input, "utf8");
-
-      const envEntries = Object.entries(request.env).filter(
-        ([, value]) => value !== undefined,
-      ) as Array<[string, string]>;
-      const envPrefix = envEntries
-        .map(([key, value]) => `${key}=${quoteForSh(value)}`)
-        .join(" ");
-
-      const quotedArgs = request.args.map((arg) => quoteForSh(arg)).join(" ");
-      const command = `${envPrefix} ${quoteForSh(request.cliPath)} ${quotedArgs}`.trim();
-      const script = buildShellCaptureScript(command, ipc, quoteForSh);
-
-      const splitFlag = normalizeSplitFlag(this.options.splitFlag);
-      const tmuxArgs = ["split-window", splitFlag, "-P", "-F", "#{pane_id}"];
-      if (this.options.splitTarget) {
-        tmuxArgs.push("-t", this.options.splitTarget);
-      }
-      // On Windows (psmux), run directly — no bash wrapper needed.
-      // On Unix (tmux), wrap in bash login shell.
-      if (isWindows) {
-        tmuxArgs.push(script);
-      } else {
-        tmuxArgs.push(`bash -lc ${quoteForSh(script)}`);
-      }
-
-      const split = await execFileAsync(tmuxPath, tmuxArgs, { timeout: 5000 });
-      if (split.exitCode !== 0) {
-        return {
-          stdout: "",
-          stderr: `tmux pane launch failed: ${split.stderr.trim()}`,
-          exitCode: 1,
-          killed: false,
-          signal: null,
-        };
-      }
-
-      const paneId = split.stdout.trim().split(/\r?\n/).pop() ?? "";
-      const finished = await waitForSentinelFile(ipc.sentinelPath, request.timeoutMs);
-
-      if (!finished) {
-        if (paneId) {
-          await execFileAsync(tmuxPath, ["kill-pane", "-t", paneId], { timeout: 3000 });
-        }
-        return {
-          stdout: "",
-          stderr: "",
-          exitCode: -1,
-          killed: true,
-          signal: "SIGTERM",
-        };
-      }
-
-      const exitCode = readSentinelExitCode(ipc.sentinelPath, 1);
-      const stdout = readTextIfExists(ipc.stdoutPath);
-      const stderr = readTextIfExists(ipc.stderrPath);
-
-      if (request.outputFilePath && fs.existsSync(request.outputFilePath)) {
-        return {
-          stdout: fs.readFileSync(request.outputFilePath, "utf8"),
-          stderr,
-          exitCode,
-          killed: false,
-          signal: null,
-        };
-      }
-
-      return { stdout, stderr, exitCode, killed: false, signal: null };
-    } finally {
-      cleanupSentinelIpc(ipc);
-    }
-  }
-}
-
-

package/dist/templates/core/lib-ts/agent-exec/execution-backend.ts

@@ -1,50 +0,0 @@
-/**
- * Execution backend interfaces for CLI agent subprocess invocations.
- * Decouples agent logic (prompt building, output parsing) from execution
- * strategy (headless subprocess vs tmux pane).
- */
-
-// ---------------------------------------------------------------------------
-// Execution Request / Result
-// ---------------------------------------------------------------------------
-
-/** Request to execute a CLI subprocess. */
-export interface ExecutionRequest {
-  cliPath: string;
-  args: string[];
-  input: string;
-  env: Record<string, string | undefined>;
-  timeoutMs: number;
-  /** If set, read output from this file instead of stdout (Codex pattern). */
-  outputFilePath?: string;
-  maxBuffer?: number;
-  shell?: boolean;
-}
-
-/** Result from a CLI subprocess execution. */
-export interface ExecutionResult {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-  killed: boolean;
-  signal: string | null;
-}
-
-// ---------------------------------------------------------------------------
-// Execution Backend
-// ---------------------------------------------------------------------------
-
-/** Strategy interface for running CLI agent subprocesses. */
-export interface ExecutionBackend {
-  execute(request: ExecutionRequest): Promise<ExecutionResult>;
-}
-
-// ---------------------------------------------------------------------------
-// Debug Logger
-// ---------------------------------------------------------------------------
-
-/** Injectable debug logger for agents running in core context. */
-export interface AgentDebugLogger {
-  log(contextPath: string, sessionName: string, component: string, message: string, data?: unknown): void;
-  raw(contextPath: string, sessionName: string, component: string, label: string, raw: string): void;
-}

package/dist/templates/core/lib-ts/agent-exec/index.ts

@@ -1,6 +0,0 @@
-export { HeadlessBackend } from "./backends/headless.js";
-export { TmuxBackend } from "./backends/tmux.js";
-export { type AgentExecutionConfig, BaseCliAgent } from "./base-agent.js";
-export type { AgentDebugLogger, ExecutionBackend, ExecutionRequest, ExecutionResult } from "./execution-backend.js";
-export { parseJsonObjectMaybe, parseStructuredOutput } from "./structured-output.js";
-export type { StructuredOutputParseOptions } from "./structured-output.js";

package/dist/templates/core/lib-ts/agent-exec/structured-output.ts

@@ -1,165 +0,0 @@
-/**
- * Shared structured output parsing utilities for CLI-based agents.
- * Supports Claude/Codex-style envelopes and heuristic JSON extraction.
- */
-
-import { logDebug, logError, logWarn } from "../runtime/logger.js";
-
-export interface StructuredOutputParseOptions {
-  requireFields?: string[];
-  loggerTag?: string;
-}
-
-const DEFAULT_LOG_TAG = "structured_output";
-
-function getTag(options?: StructuredOutputParseOptions): string {
-  return options?.loggerTag ?? DEFAULT_LOG_TAG;
-}
-
-function validateRequiredFields(
-  obj: Record<string, unknown>,
-  parseMethod: "strict" | "heuristic",
-  options?: StructuredOutputParseOptions,
-): Record<string, unknown> | null {
-  const required = options?.requireFields;
-  if (!required || required.length === 0) return obj;
-
-  const missing = required.filter((field) => !(field in obj) || obj[field] === undefined || obj[field] === null);
-  if (missing.length === 0) return obj;
-
-  const tag = getTag(options);
-  logWarn(tag, `Parsed JSON (${parseMethod}) missing required fields: ${JSON.stringify(missing)}`);
-  logDebug(tag, `Parsed keys: ${JSON.stringify(Object.keys(obj))}`);
-
-  // Heuristic extraction often grabs the wrong JSON blob. Reject in that case.
-  if (parseMethod === "heuristic") {
-    return null;
-  }
-  return obj;
-}
-
-/**
- * Parse a JSON object from text using strict parse first, then heuristic
- * extraction of the first object-like block.
- */
-export function parseJsonObjectMaybe(
-  text: string,
-  options?: StructuredOutputParseOptions,
-): Record<string, unknown> | null {
-  const tag = getTag(options);
-  const trimmed = text.trim();
-  if (!trimmed) return null;
-
-  // Strict parse first.
-  try {
-    const parsed: unknown = JSON.parse(trimmed);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return validateRequiredFields(parsed as Record<string, unknown>, "strict", options);
-    }
-  } catch {
-    // Fall through to heuristic extraction.
-  }
-
-  // Heuristic parse: extract the first object-like block.
-  const start = trimmed.indexOf("{");
-  const end = trimmed.lastIndexOf("}");
-  if (start === -1 || end === -1 || end <= start) return null;
-
-  const candidate = trimmed.slice(start, end + 1);
-  try {
-    const parsed: unknown = JSON.parse(candidate);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      logDebug(tag, `Used heuristic JSON extraction (chars ${start}-${end})`);
-      return validateRequiredFields(parsed as Record<string, unknown>, "heuristic", options);
-    }
-  } catch {
-    logDebug(tag, `Heuristic JSON extraction failed (chars ${start}-${end})`);
-  }
-
-  return null;
-}
-
-function parseAssistantEnvelope(
-  envelope: Record<string, unknown>,
-  options?: StructuredOutputParseOptions,
-): Record<string, unknown> | null {
-  const tag = getTag(options);
-  const {message} = envelope;
-  if (!message || typeof message !== "object") return null;
-
-  const {content} = (message as Record<string, unknown>);
-  if (!Array.isArray(content)) return null;
-
-  for (const item of content) {
-    if (!item || typeof item !== "object") continue;
-    const toolUse = item as Record<string, unknown>;
-    if (toolUse.name !== "StructuredOutput") continue;
-    if (toolUse.input && typeof toolUse.input === "object" && !Array.isArray(toolUse.input)) {
-      logDebug(tag, "Found StructuredOutput in assistant envelope");
-      return toolUse.input as Record<string, unknown>;
-    }
-  }
-  return null;
-}
-
-/**
- * Parse structured output across known CLI envelope formats.
- * Falls back to generic JSON extraction when no recognized envelope exists.
- */
-export function parseStructuredOutput(
-  raw: string,
-  options?: StructuredOutputParseOptions,
-): Record<string, unknown> | null {
-  const tag = getTag(options);
-
-  try {
-    const parsed: unknown = JSON.parse(raw);
-
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      const obj = parsed as Record<string, unknown>;
-
-      if (obj.structured_output && typeof obj.structured_output === "object" && !Array.isArray(obj.structured_output)) {
-        logDebug(tag, "Found structured_output in root object");
-        return validateRequiredFields(obj.structured_output as Record<string, unknown>, "strict", options);
-      }
-
-      const assistantResult = parseAssistantEnvelope(obj, options);
-      if (assistantResult) return assistantResult;
-
-      // Session result envelope (no structured output tool call).
-      if (obj.type === "result" || ("duration_ms" in obj && "session_id" in obj)) {
-        if (obj.is_error === true || (Array.isArray(obj.errors) && obj.errors.length > 0)) {
-          logWarn(tag, `CLI returned error envelope: ${JSON.stringify(obj.errors ?? "is_error=true")}`);
-          return null;
-        }
-
-        if (typeof obj.result === "string" && obj.result.trim().length > 0) {
-          logDebug(tag, "Found text result in session envelope, attempting JSON extraction");
-          const extracted = parseJsonObjectMaybe(obj.result, options);
-          if (extracted) return extracted;
-          logWarn(tag, "Session envelope result contained no extractable JSON object");
-        }
-        return null;
-      }
-    } else if (Array.isArray(parsed)) {
-      for (const [i, event] of parsed.entries()) {
-        if (!event || typeof event !== "object") continue;
-        const eventObj = event as Record<string, unknown>;
-        const assistantResult = parseAssistantEnvelope(eventObj, options);
-        if (assistantResult) {
-          logDebug(tag, `Found StructuredOutput in event[${i}]`);
-          return assistantResult;
-        }
-      }
-    }
-  } catch (error: unknown) {
-    if (error instanceof SyntaxError) {
-      logWarn(tag, `JSON decode error: ${error.message}`);
-    } else {
-      logError(tag, `Unexpected parse error: ${error}`);
-    }
-  }
-
-  logDebug(tag, "No structured envelope found, falling back to generic JSON extraction");
-  return parseJsonObjectMaybe(raw, options);
-}