@akiojin/gwt 4.11.6 → 4.12.0

package/src/gemini.ts

@@ -9,6 +9,10 @@ import {
 } from "./utils/terminal.js";
 import { findCommand } from "./utils/command.js";
 import { findLatestGeminiSessionId } from "./utils/session.js";
+import {
+  runAgentWithPty,
+  shouldCaptureAgentOutput,
+} from "./logging/agentOutput.js";
 
 const GEMINI_CLI_PACKAGE = "@google/gemini-cli";
 
@@ -45,6 +49,7 @@ export async function launchGeminiCLI(
     envOverrides?: Record<string, string>;
     model?: string;
     sessionId?: string | null;
+    branch?: string | null;
     version?: string | null;
   } = {},
 ): Promise<{ sessionId?: string | null }> {
@@ -154,8 +159,8 @@ export async function launchGeminiCLI(
         (entry): entry is [string, string] => typeof entry[1] === "string",
       ),
     );
-
-    const childStdio = createChildStdio();
+    const captureOutput = shouldCaptureAgentOutput(baseEnv);
+    const childStdio = captureOutput ? null : createChildStdio();
 
     // Auto-detect locally installed gemini command
     const geminiLookup = await findCommand("gemini");
@@ -166,7 +171,17 @@ export async function launchGeminiCLI(
 
     // Determine execution strategy based on version selection
     // FR-063b: "installed" option only appears when local command exists
-    const selectedVersion = options.version ?? "installed";
+    const requestedVersion = options.version ?? "latest";
+    let selectedVersion = requestedVersion;
+
+    if (requestedVersion === "installed" && !geminiLookup.path) {
+      writeTerminalLine(
+        chalk.yellow(
+          "   ⚠️  Installed gemini command not found. Falling back to latest.",
+        ),
+      );
+      selectedVersion = "latest";
+    }
 
     // Log version information (FR-072)
     if (selectedVersion === "installed") {
@@ -188,8 +203,35 @@ export async function launchGeminiCLI(
           throw execError;
         }
       };
+      // Treat SIGHUP (1), SIGINT (2), SIGTERM (15) as normal exit signals
+      // SIGHUP can occur when the PTY closes, SIGINT/SIGTERM are user interrupts
+      const isNormalExitSignal = (signal?: number | null) =>
+        signal === 1 || signal === 2 || signal === 15;
 
       const run = async (cmd: string, args: string[]) => {
+        if (captureOutput) {
+          const result = await runAgentWithPty({
+            command: cmd,
+            args,
+            cwd: worktreePath,
+            env: baseEnv,
+            agentId: "gemini-cli",
+          });
+          if (isNormalExitSignal(result.signal)) {
+            return;
+          }
+          if (result.exitCode !== null && result.exitCode !== 0) {
+            throw new Error(
+              `Gemini CLI exited with code ${result.exitCode ?? "unknown"}`,
+            );
+          }
+          return;
+        }
+
+        if (!childStdio) {
+          return;
+        }
+
         const child = execa(cmd, args, {
           cwd: worktreePath,
           stdin: childStdio.stdin,
@@ -237,7 +279,7 @@ export async function launchGeminiCLI(
         }
       }
     } finally {
-      childStdio.cleanup();
+      childStdio?.cleanup();
     }
 
     const explicitResumeSucceeded = usedExplicitSessionId && !fellBackToLatest;
@@ -253,6 +295,10 @@ export async function launchGeminiCLI(
         capturedSessionId =
           (await findLatestGeminiSessionId(worktreePath, {
             cwd: worktreePath,
+            branch: options.branch ?? null,
+            worktrees: options.branch
+              ? [{ path: worktreePath, branch: options.branch }]
+              : null,
           })) ?? null;
       } catch {
         capturedSessionId = null;

package/src/index.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect, spyOn, beforeEach, afterEach } from "bun:test";
+import { getPackageVersion } from "./utils";
 import * as utils from "./utils";
 
 // showVersion関数のテスト（TDD Green phase）
@@ -28,7 +29,6 @@ describe("showVersion via CLI args", () => {
     consoleLogSpy.mockRestore();
     consoleErrorSpy.mockRestore();
     processExitSpy.mockRestore();
-
     // process.argvを復元
     process.argv = originalArgv;
   });
@@ -37,32 +37,34 @@ describe("showVersion via CLI args", () => {
     // Arrange: CLIフラグを設定
     process.argv = ["node", "index.js", "--version"];
 
-    // getPackageVersion()をモック
-    const mockVersion = "2.6.1";
-    spyOn(utils, "getPackageVersion").mockResolvedValue(mockVersion);
+    const expectedVersion = await getPackageVersion();
+    if (!expectedVersion) {
+      throw new Error("Failed to resolve package version for test.");
+    }
 
     // Act: main()を呼び出す
     const { main } = await import("./index");
     await main();
 
     // Assert: 標準出力にバージョンが表示されることを期待
-    expect(consoleLogSpy).toHaveBeenCalledWith(mockVersion);
+    expect(consoleLogSpy).toHaveBeenCalledWith(expectedVersion);
   }, 30000);
 
   it("正常系: -vフラグでバージョンを表示する", async () => {
     // Arrange: CLIフラグを設定
     process.argv = ["node", "index.js", "-v"];
 
-    // getPackageVersion()をモック
-    const mockVersion = "1.12.3";
-    spyOn(utils, "getPackageVersion").mockResolvedValue(mockVersion);
+    const expectedVersion = await getPackageVersion();
+    if (!expectedVersion) {
+      throw new Error("Failed to resolve package version for test.");
+    }
 
     // Act: main()を呼び出す
     const { main } = await import("./index");
     await main();
 
     // Assert: 標準出力にバージョンが表示されることを期待
-    expect(consoleLogSpy).toHaveBeenCalledWith(mockVersion);
+    expect(consoleLogSpy).toHaveBeenCalledWith(expectedVersion);
   }, 30000);
 
   // Note: This test is skipped due to module caching issues in CI environment
@@ -72,7 +74,10 @@ describe("showVersion via CLI args", () => {
     process.argv = ["node", "index.js", "--version"];
 
     // getPackageVersion()をモックしてnullを返す
-    spyOn(utils, "getPackageVersion").mockResolvedValue(null);
+    const getPackageVersionSpy = spyOn(
+      utils,
+      "getPackageVersion",
+    ).mockResolvedValue(null);
 
     // Act: main()を呼び出す
     const { main } = await import("./index");
@@ -83,5 +88,6 @@ describe("showVersion via CLI args", () => {
       expect.stringContaining("Error"),
     );
     expect(processExitSpy).toHaveBeenCalledWith(1);
+    getPackageVersionSpy.mockRestore();
   });
 });

package/src/index.ts

@@ -27,6 +27,7 @@ import {
   isProtectedBranchName,
   switchToProtectedBranch,
   resolveWorktreePathForBranch,
+  listAllWorktrees,
   repairWorktreePath,
 } from "./worktree.js";
 import {
@@ -192,6 +193,11 @@ function performTerminalCleanup(): void {
  * Returns SelectionResult if user made selections, undefined if user quit
  */
 async function mainSolidUI(): Promise<SelectionResult | undefined> {
+  if (!("Bun" in globalThis)) {
+    throw new Error(
+      "OpenTUI requires the Bun runtime. Run with Bun (e.g. bunx @akiojin/gwt@latest).",
+    );
+  }
   const { renderSolidApp } = await import("./opentui/index.solid.js");
   const terminal = getTerminalStreams();
 
@@ -629,6 +635,7 @@ export async function handleAIToolWorkflow(
           model?: string;
           sessionId?: string | null;
           chrome?: boolean;
+          branch?: string | null;
           version?: string | null;
         } = {
           mode:
@@ -641,6 +648,7 @@ export async function handleAIToolWorkflow(
           envOverrides: sharedEnv,
           sessionId: resumeSessionId,
           chrome: true,
+          branch,
           version: toolVersion ?? null,
         };
         if (normalizedModel) {
@@ -655,6 +663,7 @@ export async function handleAIToolWorkflow(
           model?: string;
           reasoningEffort?: CodexReasoningEffort;
           sessionId?: string | null;
+          branch?: string | null;
           version?: string | null;
         } = {
           mode:
@@ -666,6 +675,7 @@ export async function handleAIToolWorkflow(
           bypassApprovals: skipPermissions,
           envOverrides: sharedEnv,
           sessionId: resumeSessionId,
+          branch,
           version: toolVersion ?? null,
         };
         if (normalizedModel) {
@@ -683,6 +693,7 @@ export async function handleAIToolWorkflow(
           envOverrides?: Record<string, string>;
           model?: string;
           sessionId?: string | null;
+          branch?: string | null;
           version?: string | null;
         } = {
           mode:
@@ -694,6 +705,7 @@ export async function handleAIToolWorkflow(
           skipPermissions,
           envOverrides: sharedEnv,
           sessionId: resumeSessionId,
+          branch,
           version: toolVersion ?? null,
         };
         if (normalizedModel) {
@@ -734,10 +746,29 @@ export async function handleAIToolWorkflow(
       resumeSessionId ??
       null;
 
+    let resolvedWorktrees: { path: string; branch: string }[] | null = null;
+    if (branch) {
+      try {
+        const allWorktrees = await listAllWorktrees();
+        resolvedWorktrees = allWorktrees
+          .filter((entry) => entry?.path && entry?.branch)
+          .map((entry) => ({ path: entry.path, branch: entry.branch }));
+      } catch {
+        resolvedWorktrees = null;
+      }
+    }
+    const worktreeLookupOptions =
+      resolvedWorktrees && resolvedWorktrees.length > 0
+        ? { worktrees: resolvedWorktrees }
+        : {};
+
     if (!finalSessionId && tool === "claude-code") {
       try {
         finalSessionId =
-          (await findLatestClaudeSessionId(worktreePath)) ?? null;
+          (await findLatestClaudeSessionId(worktreePath, {
+            branch,
+            ...worktreeLookupOptions,
+          })) ?? null;
       } catch {
         finalSessionId = null;
       }
@@ -752,6 +783,8 @@ export async function handleAIToolWorkflow(
           preferClosestTo: finishedAt,
           windowMs: 60 * 60 * 1000,
           cwd: worktreePath,
+          branch,
+          ...worktreeLookupOptions,
         });
         if (latest) {
           finalSessionId = latest.id;
@@ -766,6 +799,8 @@ export async function handleAIToolWorkflow(
           until: finishedAt + 60_000,
           preferClosestTo: finishedAt,
           windowMs: 60 * 60 * 1000,
+          branch,
+          ...worktreeLookupOptions,
         });
         if (latestClaude) {
           finalSessionId = latestClaude.id;
@@ -781,6 +816,8 @@ export async function handleAIToolWorkflow(
           preferClosestTo: finishedAt,
           windowMs: 60 * 60 * 1000,
           cwd: worktreePath,
+          branch,
+          ...worktreeLookupOptions,
         });
         if (latestGemini) {
           finalSessionId = latestGemini.id;

package/src/launcher.ts

@@ -9,7 +9,14 @@ import { execa } from "execa";
 import chalk from "chalk";
 import type { CodingAgent, CodingAgentLaunchOptions } from "./types/tools.js";
 import { createLogger } from "./logging/logger.js";
-import { resolveVersionSuffix } from "./utils/npmRegistry.js";
+import {
+  runAgentWithPty,
+  shouldCaptureAgentOutput,
+} from "./logging/agentOutput.js";
+import {
+  parsePackageCommand,
+  resolveVersionSuffix,
+} from "./utils/npmRegistry.js";
 import { writeTerminalLine } from "./utils/terminal.js";
 
 const logger = createLogger({ category: "launcher" });
@@ -125,14 +132,32 @@ export async function launchCodingAgent(
     ...(options.sharedEnv ?? {}),
     ...(agent.env ?? {}),
   };
+  const workingDir = options.cwd ?? process.cwd();
+  const captureOutput = shouldCaptureAgentOutput(env);
 
   // execa共通オプション（cwdがundefinedの場合は含めない）
   const execaOptions = {
     stdio: "inherit" as const,
-    ...(options.cwd ? { cwd: options.cwd } : {}),
+    ...(workingDir ? { cwd: workingDir } : {}),
     env,
   };
 
+  const runWithCapture = async (command: string, commandArgs: string[]) => {
+    const result = await runAgentWithPty({
+      command,
+      args: commandArgs,
+      cwd: workingDir,
+      env,
+      agentId: agent.id,
+    });
+    if (result.signal !== null && result.signal !== undefined) {
+      throw new Error(`Coding agent terminated by signal ${result.signal}`);
+    }
+    if (result.exitCode !== null && result.exitCode !== 0) {
+      throw new Error(`Coding agent exited with code ${result.exitCode}`);
+    }
+  };
+
   logger.info(
     {
       agentId: agent.id,
@@ -146,7 +171,11 @@ export async function launchCodingAgent(
   switch (agent.type) {
     case "path": {
       // 絶対パスで直接実行
-      await execa(agent.command, args, execaOptions);
+      if (captureOutput) {
+        await runWithCapture(agent.command, args);
+      } else {
+        await execa(agent.command, args, execaOptions);
+      }
       logger.info({ agentId: agent.id }, "Coding agent completed (path)");
       break;
     }
@@ -154,9 +183,12 @@ export async function launchCodingAgent(
     case "bunx": {
       // bunx経由でパッケージ実行
       // バージョン指定がある場合はパッケージ名に付与
-      const selectedVersion = options.version ?? "installed";
-      const versionSuffix = resolveVersionSuffix(options.version);
-      const packageWithVersion = `${agent.command}${versionSuffix}`;
+      const { packageName, version: embeddedVersion } = parsePackageCommand(
+        agent.command,
+      );
+      const selectedVersion = options.version ?? embeddedVersion ?? "latest";
+      const versionSuffix = resolveVersionSuffix(selectedVersion);
+      const packageWithVersion = `${packageName}${versionSuffix}`;
 
       // FR-072: Log version information
       if (selectedVersion === "installed") {
@@ -167,7 +199,12 @@ export async function launchCodingAgent(
       writeTerminalLine(chalk.cyan(`   🔄 Using bunx ${packageWithVersion}`));
 
       // bunx [package@version] [args...]
-      await execa("bunx", [packageWithVersion, ...args], execaOptions);
+      const bunxCommand = captureOutput ? await resolveCommand("bunx") : "bunx";
+      if (captureOutput) {
+        await runWithCapture(bunxCommand, [packageWithVersion, ...args]);
+      } else {
+        await execa("bunx", [packageWithVersion, ...args], execaOptions);
+      }
       logger.info(
         { agentId: agent.id, version: selectedVersion },
         "Coding agent completed (bunx)",
@@ -178,7 +215,11 @@ export async function launchCodingAgent(
     case "command": {
       // PATH解決 → 実行
       const resolvedPath = await resolveCommand(agent.command);
-      await execa(resolvedPath, args, execaOptions);
+      if (captureOutput) {
+        await runWithCapture(resolvedPath, args);
+      } else {
+        await execa(resolvedPath, args, execaOptions);
+      }
       logger.info({ agentId: agent.id }, "Coding agent completed (command)");
       break;
     }

package/src/logging/agentOutput.ts

@@ -0,0 +1,216 @@
+import * as pty from "node-pty";
+import type { IPty } from "node-pty";
+import { createLogger } from "./logger.js";
+import { resolveLogDir } from "./reader.js";
+import { getTerminalStreams } from "../utils/terminal.js";
+
+export const CAPTURE_AGENT_OUTPUT_ENV = "GWT_CAPTURE_AGENT_OUTPUT";
+
+export function shouldCaptureAgentOutput(
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  const raw = env[CAPTURE_AGENT_OUTPUT_ENV];
+  if (raw === undefined) {
+    // Default to false to avoid PTY stdin/stdout conflicts with OpenTUI.
+    // Set GWT_CAPTURE_AGENT_OUTPUT=true to enable agent output logging.
+    return false;
+  }
+  const normalized = String(raw).trim().toLowerCase();
+  if (!normalized) {
+    return false;
+  }
+  return normalized === "true" || normalized === "1";
+}
+
+// eslint-disable-next-line no-control-regex
+const ANSI_PATTERN = new RegExp("\\u001b\\[[0-9;]*[A-Za-z]", "g");
+
+export function stripAnsi(value: string): string {
+  return value.replace(ANSI_PATTERN, "");
+}
+
+export interface AgentOutputLineBuffer {
+  push: (chunk: string) => void;
+  flush: () => void;
+}
+
+export function createAgentOutputLineBuffer(
+  onLine: (line: string) => void,
+): AgentOutputLineBuffer {
+  let buffer = "";
+
+  const push = (chunk: string) => {
+    const normalized = chunk.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    buffer += normalized;
+    while (true) {
+      const index = buffer.indexOf("\n");
+      if (index === -1) {
+        break;
+      }
+      const line = buffer.slice(0, index);
+      buffer = buffer.slice(index + 1);
+      onLine(line);
+    }
+  };
+
+  const flush = () => {
+    if (!buffer) {
+      return;
+    }
+    const line = buffer;
+    buffer = "";
+    onLine(line);
+  };
+
+  return { push, flush };
+}
+
+export interface AgentOutputCaptureOptions {
+  command: string;
+  args: string[];
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  agentId: string;
+}
+
+export interface AgentOutputCaptureResult {
+  exitCode: number | null;
+  signal?: number | null;
+}
+
+const normalizeEnv = (env: NodeJS.ProcessEnv): Record<string, string> =>
+  Object.fromEntries(
+    Object.entries(env).filter(
+      (entry): entry is [string, string] => typeof entry[1] === "string",
+    ),
+  );
+
+const getTerminalSize = (terminal: ReturnType<typeof getTerminalStreams>) => {
+  const stdout = terminal.stdout as
+    | (NodeJS.WriteStream & { columns?: number; rows?: number })
+    | undefined;
+  const cols = stdout?.columns ?? process.stdout.columns ?? 80;
+  const rows = stdout?.rows ?? process.stdout.rows ?? 24;
+  return { cols, rows };
+};
+
+export async function runAgentWithPty(
+  options: AgentOutputCaptureOptions,
+): Promise<AgentOutputCaptureResult> {
+  const terminal = getTerminalStreams();
+  const { cols, rows } = getTerminalSize(terminal);
+  const logDir = resolveLogDir(options.cwd);
+  const stdoutLogger = createLogger({
+    category: "agent.stdout",
+    logDir,
+    base: { agentId: options.agentId },
+  });
+  const stderrLogger = createLogger({
+    category: "agent.stderr",
+    logDir,
+    base: { agentId: options.agentId },
+  });
+
+  const normalizedEnv = normalizeEnv(options.env);
+  const ptyProcess: IPty = pty.spawn(options.command, options.args, {
+    name: process.env.TERM ?? "xterm-256color",
+    cols,
+    rows,
+    cwd: options.cwd,
+    env: normalizedEnv,
+  });
+
+  const lineBuffer = createAgentOutputLineBuffer((line) => {
+    const cleaned = stripAnsi(line).trimEnd();
+    if (!cleaned) {
+      return;
+    }
+    stdoutLogger.info(cleaned);
+  });
+
+  const stdout = terminal.stdout;
+  const writeToTerminal =
+    stdout && typeof stdout.write === "function"
+      ? stdout.write.bind(stdout)
+      : null;
+
+  ptyProcess.onData((data) => {
+    if (writeToTerminal) {
+      try {
+        writeToTerminal(data);
+      } catch {
+        // Ignore terminal write errors.
+      }
+    }
+    lineBuffer.push(data);
+  });
+
+  const stdin = terminal.stdin;
+  const handleInput = (chunk: Buffer | string) => {
+    const data = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    ptyProcess.write(data);
+  };
+
+  const stdinWasRaw =
+    stdin &&
+    typeof (stdin as NodeJS.ReadStream & { isRaw?: boolean }).isRaw ===
+      "boolean"
+      ? (stdin as NodeJS.ReadStream & { isRaw?: boolean }).isRaw
+      : undefined;
+
+  if (stdin && typeof stdin.on === "function") {
+    if (stdin.isTTY && typeof stdin.setRawMode === "function") {
+      try {
+        stdin.setRawMode(true);
+      } catch {
+        // Ignore raw mode errors.
+      }
+    }
+    if (typeof stdin.resume === "function") {
+      stdin.resume();
+    }
+    stdin.on("data", handleInput);
+  }
+
+  const handleResize = () => {
+    const next = getTerminalSize(terminal);
+    try {
+      ptyProcess.resize(next.cols, next.rows);
+    } catch {
+      // Ignore resize errors.
+    }
+  };
+  if (process.stdout && typeof process.stdout.on === "function") {
+    process.stdout.on("resize", handleResize);
+  }
+
+  return await new Promise<AgentOutputCaptureResult>((resolve) => {
+    ptyProcess.onExit(({ exitCode, signal }) => {
+      lineBuffer.flush();
+      if (stdin && typeof stdin.off === "function") {
+        stdin.off("data", handleInput);
+      }
+      if (stdin && typeof stdin.pause === "function") {
+        stdin.pause();
+      }
+      if (stdin && stdin.isTTY && typeof stdin.setRawMode === "function") {
+        try {
+          stdin.setRawMode(Boolean(stdinWasRaw));
+        } catch {
+          // Ignore raw mode restore errors.
+        }
+      }
+      if (process.stdout && typeof process.stdout.off === "function") {
+        process.stdout.off("resize", handleResize);
+      }
+      if (exitCode !== null && exitCode !== 0) {
+        stderrLogger.error(
+          { exitCode, signal },
+          "Agent exited with non-zero code",
+        );
+      }
+      const normalizedSignal = signal ?? null;
+      resolve({ exitCode, signal: normalizedSignal });
+    });
+  });
+}

package/src/logging/formatter.ts

@@ -19,17 +19,36 @@ const LEVEL_LABELS: Record<number, string> = {
   60: "FATAL",
 };
 
+const LOCAL_TIME_FORMATTER = new Intl.DateTimeFormat(undefined, {
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit",
+  hour12: false,
+});
+
+const formatLocalTimeParts = (date: Date): string => {
+  const parts = LOCAL_TIME_FORMATTER.formatToParts(date);
+  const get = (type: Intl.DateTimeFormatPartTypes) =>
+    parts.find((part) => part.type === type)?.value;
+  const hour = get("hour");
+  const minute = get("minute");
+  const second = get("second");
+
+  if (!hour || !minute || !second) {
+    return LOCAL_TIME_FORMATTER.format(date);
+  }
+
+  return `${hour}:${minute}:${second}`;
+};
+
 const formatTimeLabel = (
   value: unknown,
 ): { label: string; timestamp: number | null } => {
   if (typeof value === "string" || typeof value === "number") {
     const date = new Date(value);
     if (!Number.isNaN(date.getTime())) {
-      const hours = String(date.getHours()).padStart(2, "0");
-      const minutes = String(date.getMinutes()).padStart(2, "0");
-      const seconds = String(date.getSeconds()).padStart(2, "0");
       return {
-        label: `${hours}:${minutes}:${seconds}`,
+        label: formatLocalTimeParts(date),
         timestamp: date.getTime(),
       };
     }

package/src/logging/logger.ts

@@ -59,6 +59,7 @@ export function createLogger(config: LoggerConfig = {}): Logger {
     const destinationStream = pino.destination({
       dest: destination,
       sync: true,
+      append: true,
     });
     return pino(options, destinationStream);
   }
@@ -89,6 +90,7 @@ export function createLogger(config: LoggerConfig = {}): Logger {
   const destinationStream = pino.destination({
     dest: destination,
     sync: false,
+    append: true,
   });
   return pino(options, destinationStream);
 }