@akiojin/gwt 4.11.6 → 4.12.1

package/src/codex.ts

@@ -13,8 +13,18 @@ import {
   waitForCodexSessionId,
 } from "./utils/session.js";
 import { findCommand } from "./utils/command.js";
+import {
+  runAgentWithPty,
+  shouldCaptureAgentOutput,
+} from "./logging/agentOutput.js";
+import { createLogger } from "./logging/logger.js";
+import {
+  shouldEnableCodexSkillsFlag,
+  withCodexSkillsFlag,
+} from "./shared/codingAgentConstants.js";
 
 const CODEX_CLI_PACKAGE = "@openai/codex";
+const logger = createLogger({ category: "codex" });
 
 /**
  * Reasoning effort levels supported by Codex CLI.
@@ -43,8 +53,6 @@ export const buildDefaultCodexArgs = (
 ): string[] => [
   "--enable",
   "web_search_request",
-  "--enable",
-  "skills",
   `--model=${model}`,
   "--sandbox",
   "workspace-write",
@@ -96,6 +104,7 @@ export async function launchCodexCLI(
     model?: string;
     reasoningEffort?: CodexReasoningEffort;
     sessionId?: string | null;
+    branch?: string | null;
     version?: string | null;
   } = {},
 ): Promise<{ sessionId?: string | null }> {
@@ -166,7 +175,18 @@ export async function launchCodexCLI(
       args.push(...options.extraArgs);
     }
 
-    const codexArgs = buildDefaultCodexArgs(model, reasoningEffort);
+    const requestedVersion = options.version ?? "latest";
+    const codexLookup = await findCommand("codex");
+    const skillsFlagVersion =
+      requestedVersion === "installed"
+        ? (codexLookup.version ?? null)
+        : requestedVersion === "latest"
+          ? null
+          : requestedVersion;
+    const codexArgs = withCodexSkillsFlag(
+      buildDefaultCodexArgs(model, reasoningEffort),
+      shouldEnableCodexSkillsFlag(skillsFlagVersion),
+    );
 
     args.push(...codexArgs);
 
@@ -175,8 +195,6 @@ export async function launchCodexCLI(
     terminal.exitRawMode();
     resetTerminalModes(terminal.stdout);
 
-    const childStdio = createChildStdio();
-
     const env = Object.fromEntries(
       Object.entries({
         ...process.env,
@@ -185,26 +203,116 @@ export async function launchCodexCLI(
         (entry): entry is [string, string] => typeof entry[1] === "string",
       ),
     );
+    const captureOutput = shouldCaptureAgentOutput(env);
+    const childStdio = captureOutput ? null : createChildStdio();
 
-    // Auto-detect locally installed codex command
-    const codexLookup = await findCommand("codex");
+    // codexLookup is used to decide local vs bunx execution
 
     const execChild = async (child: Promise<unknown>) => {
       try {
-        await child;
+        const result = (await child) as {
+          exitCode?: number | null;
+          signal?: string | null;
+        };
+        return {
+          exitCode: result.exitCode ?? 0,
+          signal: result.signal ?? null,
+        };
       } catch (execError: unknown) {
         // Treat SIGINT/SIGTERM as normal exit (user pressed Ctrl+C)
         const signal = (execError as { signal?: unknown })?.signal;
+        const exitCode =
+          (execError as { exitCode?: number | null })?.exitCode ?? null;
         if (signal === "SIGINT" || signal === "SIGTERM") {
+          return { exitCode, signal };
+        }
+        throw execError;
+      }
+    };
+    // Treat SIGINT (2), SIGTERM (15) as normal exit signals (user interrupts)
+    const isNormalExitSignal = (signal?: number | null) =>
+      signal === 2 || signal === 15;
+    const runCommand = async (command: string, commandArgs: string[]) => {
+      const runStartedAt = Date.now();
+      if (captureOutput) {
+        const result = await runAgentWithPty({
+          command,
+          args: commandArgs,
+          cwd: worktreePath,
+          env,
+          agentId: "codex-cli",
+        });
+        const durationMs = Date.now() - runStartedAt;
+        const exitCode = result.exitCode ?? null;
+        const signal = result.signal ?? null;
+        const signalIsNormal = isNormalExitSignal(signal);
+        const hasError =
+          (!signalIsNormal && signal !== null && signal !== undefined) ||
+          (exitCode !== null && exitCode !== 0);
+        if (hasError) {
+          logger.error({ exitCode, signal, durationMs }, "Codex CLI exited");
+        } else {
+          logger.info({ exitCode, signal, durationMs }, "Codex CLI exited");
+        }
+        if (signalIsNormal) {
           return;
         }
+        if (signal !== null && signal !== undefined) {
+          throw new Error(`Codex CLI terminated by signal ${signal}`);
+        }
+        if (exitCode !== null && exitCode !== 0) {
+          throw new Error(
+            `Codex CLI exited with code ${exitCode ?? "unknown"}`,
+          );
+        }
+        return;
+      }
+
+      if (!childStdio) {
+        return;
+      }
+
+      try {
+        const child = execa(command, commandArgs, {
+          cwd: worktreePath,
+          stdin: childStdio.stdin,
+          stdout: childStdio.stdout,
+          stderr: childStdio.stderr,
+          env,
+        });
+        const result = await execChild(child);
+        const durationMs = Date.now() - runStartedAt;
+        logger.info(
+          {
+            exitCode: result.exitCode ?? null,
+            signal: result.signal,
+            durationMs,
+          },
+          "Codex CLI exited",
+        );
+      } catch (execError: unknown) {
+        const durationMs = Date.now() - runStartedAt;
+        const exitCode =
+          (execError as { exitCode?: number | null })?.exitCode ?? null;
+        const signal =
+          (execError as { signal?: string | null })?.signal ?? null;
+        logger.error({ exitCode, signal, durationMs }, "Codex CLI failed");
         throw execError;
       }
     };
 
     // Determine execution strategy based on version selection
     // FR-063b: "installed" option only appears when local command exists
-    const selectedVersion = options.version ?? "installed";
+    let selectedVersion = requestedVersion;
+
+    if (requestedVersion === "installed" && !codexLookup.path) {
+      writeTerminalLine(
+        chalk.yellow(
+          "   ⚠️  Installed codex command not found. Falling back to latest.",
+        ),
+      );
+      selectedVersion = "latest";
+    }
 
     // Log version information (FR-072)
     if (selectedVersion === "installed") {
@@ -220,30 +328,16 @@ export async function launchCodexCLI(
         writeTerminalLine(
           chalk.green("   ✨ Using locally installed codex command"),
         );
-        const child = execa(codexLookup.path, args, {
-          cwd: worktreePath,
-          stdin: childStdio.stdin,
-          stdout: childStdio.stdout,
-          stderr: childStdio.stderr,
-          env,
-        });
-        await execChild(child);
+        await runCommand(codexLookup.path, args);
       } else {
         // FR-067, FR-068: Use bunx with version suffix for latest/specific versions
         const packageWithVersion = `${CODEX_CLI_PACKAGE}@${selectedVersion}`;
         writeTerminalLine(chalk.cyan(`   🔄 Using bunx ${packageWithVersion}`));
 
-        const child = execa("bunx", [packageWithVersion, ...args], {
-          cwd: worktreePath,
-          stdin: childStdio.stdin,
-          stdout: childStdio.stdout,
-          stderr: childStdio.stderr,
-          env,
-        });
-        await execChild(child);
+        await runCommand("bunx", [packageWithVersion, ...args]);
       }
     } finally {
-      childStdio.cleanup();
+      childStdio?.cleanup();
     }
 
     // File-based session detection only - no stdout capture
@@ -257,6 +351,10 @@ export async function launchCodexCLI(
         preferClosestTo: finishedAt,
         windowMs: 10 * 60 * 1000,
         cwd: worktreePath,
+        branch: options.branch ?? null,
+        worktrees: options.branch
+          ? [{ path: worktreePath, branch: options.branch }]
+          : null,
       });
       const detectedSessionId = latest?.id ?? null;
       // When we explicitly resumed a specific session, keep that ID as the source of truth.

package/src/config/__tests__/saveSession.test.ts

@@ -53,7 +53,7 @@ describe("saveSession", () => {
     expect(loaded?.history?.[0]?.toolVersion).toBe("2.1.1");
   });
 
-  it("should save null toolVersion when not provided", async () => {
+  it("should save latest toolVersion when not provided", async () => {
     // Arrange
     const sessionData = {
       lastWorktreePath: testRepoRoot,
@@ -73,7 +73,7 @@ describe("saveSession", () => {
     // Assert
     expect(loaded).not.toBeNull();
     expect(loaded?.history).toHaveLength(1);
-    expect(loaded?.history?.[0]?.toolVersion).toBeNull();
+    expect(loaded?.history?.[0]?.toolVersion).toBe("latest");
   });
 
   it("should preserve toolVersion across multiple saves", async () => {

package/src/config/index.ts

@@ -48,6 +48,14 @@ const DEFAULT_CONFIG: AppConfig = {
   worktreeNamingPattern: "{repo}-{branch}",
 };
 
+function normalizeToolVersion(version?: string | null): string {
+  if (!version) {
+    return "latest";
+  }
+  const trimmed = version.trim();
+  return trimmed.length > 0 ? trimmed : "latest";
+}
+
 /**
  * 設定ファイルを読み込む
  */
@@ -121,6 +129,7 @@ export async function saveSession(
   try {
     const sessionPath = getSessionFilePath(sessionData.repositoryRoot);
     const sessionDir = path.dirname(sessionPath);
+    const resolvedToolVersion = normalizeToolVersion(sessionData.toolVersion);
 
     // ディレクトリを作成
     await mkdir(sessionDir, { recursive: true });
@@ -154,7 +163,7 @@ export async function saveSession(
         model: sessionData.model ?? null,
         reasoningLevel: sessionData.reasoningLevel ?? null,
         skipPermissions: sessionData.skipPermissions ?? false,
-        toolVersion: sessionData.toolVersion ?? null,
+        toolVersion: resolvedToolVersion,
         timestamp: sessionData.timestamp,
       };
       existingHistory = [...existingHistory, entry].slice(-100); // keep latest 100
@@ -166,6 +175,7 @@ export async function saveSession(
       lastSessionId: sessionData.lastSessionId ?? null,
       reasoningLevel: sessionData.reasoningLevel ?? null,
       skipPermissions: sessionData.skipPermissions ?? false,
+      toolVersion: resolvedToolVersion,
     };
 
     await writeFile(sessionPath, JSON.stringify(payload, null, 2), "utf-8");

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) {
@@ -715,6 +727,9 @@ export async function handleAIToolWorkflow(
             cwd: worktreePath,
             sharedEnv,
           };
+        if (tool === "opencode" && normalizedModel) {
+          customLaunchOptions.extraArgs = ["-m", normalizedModel];
+        }
         if (toolVersion) {
           customLaunchOptions.version = toolVersion;
         }
@@ -734,10 +749,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 +786,8 @@ export async function handleAIToolWorkflow(
           preferClosestTo: finishedAt,
           windowMs: 60 * 60 * 1000,
           cwd: worktreePath,
+          branch,
+          ...worktreeLookupOptions,
         });
         if (latest) {
           finalSessionId = latest.id;
@@ -766,6 +802,8 @@ export async function handleAIToolWorkflow(
           until: finishedAt + 60_000,
           preferClosestTo: finishedAt,
           windowMs: 60 * 60 * 1000,
+          branch,
+          ...worktreeLookupOptions,
         });
         if (latestClaude) {
           finalSessionId = latestClaude.id;
@@ -781,6 +819,8 @@ export async function handleAIToolWorkflow(
           preferClosestTo: finishedAt,
           windowMs: 60 * 60 * 1000,
           cwd: worktreePath,
+          branch,
+          ...worktreeLookupOptions,
         });
         if (latestGemini) {
           finalSessionId = latestGemini.id;