@akiojin/gwt 4.10.0 → 4.12.0

package/src/cli/ui/utils/versionCache.ts

@@ -0,0 +1,93 @@
+/**
+ * Version cache for coding agents (FR-028 ~ FR-031)
+ *
+ * Provides caching mechanism for npm package versions to avoid
+ * repeated API calls during wizard navigation.
+ */
+
+import type { VersionInfo } from "../../../utils/npmRegistry.js";
+
+/**
+ * In-memory cache for agent versions
+ * Maps agentId -> VersionInfo[]
+ */
+const versionCache = new Map<string, VersionInfo[]>();
+
+/**
+ * Type for version fetch function (injectable for testing)
+ */
+export type VersionFetcher = (agentId: string) => Promise<VersionInfo[]>;
+
+/**
+ * Get cached versions for an agent
+ * @returns Cached versions or null if not cached
+ */
+export function getVersionCache(agentId: string): VersionInfo[] | null {
+  const cached = versionCache.get(agentId);
+  return cached !== undefined ? cached : null;
+}
+
+/**
+ * Check if versions are cached for an agent
+ */
+export function isVersionCachePopulated(agentId: string): boolean {
+  return versionCache.has(agentId);
+}
+
+/**
+ * Clear all cached versions
+ */
+export function clearVersionCache(): void {
+  versionCache.clear();
+}
+
+/**
+ * Prefetch versions for multiple agents in parallel
+ * This should be called at application startup
+ *
+ * @param agentIds - List of agent IDs to prefetch versions for
+ * @param fetchFn - Optional custom fetch function (for testing)
+ */
+export async function prefetchAgentVersions(
+  agentIds: string[],
+  fetchFn?: VersionFetcher,
+): Promise<void> {
+  // Import default fetcher if not provided
+  const fetcher =
+    fetchFn ??
+    (async (agentId: string) => {
+      const { fetchVersionOptionsForAgent } =
+        await import("./versionFetcher.js");
+      return fetchVersionOptionsForAgent(agentId);
+    });
+
+  // Fetch all versions in parallel
+  const results = await Promise.allSettled(
+    agentIds.map(async (agentId) => {
+      try {
+        const versions = await fetcher(agentId);
+        versionCache.set(agentId, versions);
+      } catch {
+        // On error, don't set cache (getVersionCache will return null)
+      }
+    }),
+  );
+
+  // Log any failures for debugging (silently handled)
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result && result.status === "rejected") {
+      // Silently handle - cache will return null for this agent
+    }
+  }
+}
+
+/**
+ * Set versions in cache (for testing or direct population)
+ */
+export function setVersionCache(
+  agentId: string,
+  versions: VersionInfo[],
+): void {
+  versionCache.set(agentId, versions);
+}

package/src/cli/ui/utils/versionFetcher.ts

@@ -0,0 +1,120 @@
+/**
+ * Version fetcher for coding agents
+ *
+ * Provides functions to fetch version information from npm registry
+ * and local installations.
+ */
+
+import type { VersionInfo } from "../../../utils/npmRegistry.js";
+import {
+  fetchPackageVersions,
+  parsePackageCommand,
+} from "../../../utils/npmRegistry.js";
+import { BUILTIN_CODING_AGENTS } from "../../../config/builtin-coding-agents.js";
+import { findCommand } from "../../../utils/command.js";
+import type { SelectInputItem } from "../components/solid/SelectInput.js";
+
+/**
+ * Get package name for an agent ID (only for bunx-type agents)
+ */
+export function getPackageNameForAgent(agentId: string): string | null {
+  const agent = BUILTIN_CODING_AGENTS.find((a) => a.id === agentId);
+  if (!agent || agent.type !== "bunx") {
+    return null;
+  }
+  const { packageName } = parsePackageCommand(agent.command);
+  return packageName;
+}
+
+/**
+ * Fetch version options for an agent from npm registry
+ */
+export async function fetchVersionOptionsForAgent(
+  agentId: string,
+): Promise<VersionInfo[]> {
+  const packageName = getPackageNameForAgent(agentId);
+  if (!packageName) {
+    return [];
+  }
+  return fetchPackageVersions(packageName);
+}
+
+/**
+ * Agent ID to command name mapping
+ */
+const AGENT_COMMAND_MAP: Record<string, string> = {
+  "claude-code": "claude",
+  "codex-cli": "codex",
+  "gemini-cli": "gemini",
+  opencode: "opencode",
+};
+
+/**
+ * Installed version information
+ */
+export interface InstalledVersionInfo {
+  version: string;
+  path: string;
+}
+
+/**
+ * Fetch installed version information for an agent
+ * Returns null if not installed locally
+ */
+export async function fetchInstalledVersionForAgent(
+  agentId: string,
+): Promise<InstalledVersionInfo | null> {
+  const commandName = AGENT_COMMAND_MAP[agentId];
+  if (!commandName) {
+    return null;
+  }
+
+  const result = await findCommand(commandName);
+  if (result.source !== "installed" || !result.path) {
+    return null;
+  }
+
+  // Version format: v1.0.3 -> 1.0.3
+  const version = result.version?.replace(/^v/, "") ?? "unknown";
+
+  return {
+    version,
+    path: result.path,
+  };
+}
+
+/**
+ * Convert VersionInfo to SelectInputItem for UI
+ */
+export function versionInfoToSelectItem(v: VersionInfo): SelectInputItem {
+  const item: SelectInputItem = {
+    label: v.isPrerelease ? `${v.version} (pre)` : v.version,
+    value: v.version,
+  };
+  if (v.publishedAt) {
+    item.description = new Date(v.publishedAt).toLocaleDateString();
+  }
+  return item;
+}
+
+/**
+ * Create installed option for SelectInput
+ */
+export function createInstalledOption(
+  installed: InstalledVersionInfo,
+): SelectInputItem {
+  return {
+    label: `installed@${installed.version}`,
+    value: "installed",
+    description: installed.path,
+  };
+}
+
+/**
+ * Get all bunx-type agent IDs
+ */
+export function getBunxAgentIds(): string[] {
+  return BUILTIN_CODING_AGENTS.filter((a) => a.type === "bunx").map(
+    (a) => a.id,
+  );
+}

package/src/codex.ts

@@ -6,10 +6,19 @@ import {
   createChildStdio,
   getTerminalStreams,
   resetTerminalModes,
+  writeTerminalLine,
 } from "./utils/terminal.js";
-import { findLatestCodexSession } from "./utils/session.js";
+import {
+  findLatestCodexSession,
+  waitForCodexSessionId,
+} from "./utils/session.js";
+import { findCommand } from "./utils/command.js";
+import {
+  runAgentWithPty,
+  shouldCaptureAgentOutput,
+} from "./logging/agentOutput.js";
 
-const CODEX_CLI_PACKAGE = "@openai/codex@latest";
+const CODEX_CLI_PACKAGE = "@openai/codex";
 
 /**
  * Reasoning effort levels supported by Codex CLI.
@@ -91,6 +100,8 @@ export async function launchCodexCLI(
     model?: string;
     reasoningEffort?: CodexReasoningEffort;
     sessionId?: string | null;
+    branch?: string | null;
+    version?: string | null;
   } = {},
 ): Promise<{ sessionId?: string | null }> {
   const terminal = getTerminalStreams();
@@ -101,16 +112,16 @@ export async function launchCodexCLI(
       throw new Error(`Worktree path does not exist: ${worktreePath}`);
     }
 
-    console.log(chalk.blue("🚀 Launching Codex CLI..."));
-    console.log(chalk.gray(`   Working directory: ${worktreePath}`));
+    writeTerminalLine(chalk.blue("🚀 Launching Codex CLI..."));
+    writeTerminalLine(chalk.gray(`   Working directory: ${worktreePath}`));
 
     const args: string[] = [];
     const model = options.model ?? DEFAULT_CODEX_MODEL;
     const reasoningEffort =
       options.reasoningEffort ?? DEFAULT_CODEX_REASONING_EFFORT;
 
-    console.log(chalk.green(`   🎯 Model: ${model}`));
-    console.log(chalk.green(`   🧠 Reasoning: ${reasoningEffort}`));
+    writeTerminalLine(chalk.green(`   🎯 Model: ${model}`));
+    writeTerminalLine(chalk.green(`   🧠 Reasoning: ${reasoningEffort}`));
 
     const resumeSessionId =
       options.sessionId && options.sessionId.trim().length > 0
@@ -124,36 +135,36 @@ export async function launchCodexCLI(
       case "continue":
         if (resumeSessionId) {
           args.push("resume", resumeSessionId);
-          console.log(
+          writeTerminalLine(
             chalk.cyan(
               `   ⏭️  Resuming specific Codex session: ${resumeSessionId}`,
             ),
           );
         } else {
           args.push("resume", "--last");
-          console.log(chalk.cyan("   ⏭️  Resuming last Codex session"));
+          writeTerminalLine(chalk.cyan("   ⏭️  Resuming last Codex session"));
         }
         break;
       case "resume":
         if (resumeSessionId) {
           args.push("resume", resumeSessionId);
-          console.log(
+          writeTerminalLine(
             chalk.cyan(`   🔄 Resuming Codex session: ${resumeSessionId}`),
           );
         } else {
           args.push("resume");
-          console.log(chalk.cyan("   🔄 Resume command"));
+          writeTerminalLine(chalk.cyan("   🔄 Resume command"));
         }
         break;
       case "normal":
       default:
-        console.log(chalk.green("   ✨ Starting new session"));
+        writeTerminalLine(chalk.green("   ✨ Starting new session"));
         break;
     }
 
     if (options.bypassApprovals) {
       args.push("--yolo");
-      console.log(chalk.yellow("   ⚠️  Bypassing approvals and sandbox"));
+      writeTerminalLine(chalk.yellow("   ⚠️  Bypassing approvals and sandbox"));
     }
 
     if (options.extraArgs && options.extraArgs.length > 0) {
@@ -164,13 +175,11 @@ export async function launchCodexCLI(
 
     args.push(...codexArgs);
 
-    console.log(chalk.gray(`   📋 Args: ${args.join(" ")}`));
+    writeTerminalLine(chalk.gray(`   📋 Args: ${args.join(" ")}`));
 
     terminal.exitRawMode();
     resetTerminalModes(terminal.stdout);
 
-    const childStdio = createChildStdio();
-
     const env = Object.fromEntries(
       Object.entries({
         ...process.env,
@@ -179,22 +188,53 @@ export async function launchCodexCLI(
         (entry): entry is [string, string] => typeof entry[1] === "string",
       ),
     );
+    const captureOutput = shouldCaptureAgentOutput(env);
+    const childStdio = captureOutput ? null : createChildStdio();
 
-    try {
-      const execChild = async (child: Promise<unknown>) => {
-        try {
-          await child;
-        } catch (execError: unknown) {
-          // Treat SIGINT/SIGTERM as normal exit (user pressed Ctrl+C)
-          const signal = (execError as { signal?: unknown })?.signal;
-          if (signal === "SIGINT" || signal === "SIGTERM") {
-            return;
-          }
-          throw execError;
+    // Auto-detect locally installed codex command
+    const codexLookup = await findCommand("codex");
+
+    const execChild = async (child: Promise<unknown>) => {
+      try {
+        await child;
+      } catch (execError: unknown) {
+        // Treat SIGINT/SIGTERM as normal exit (user pressed Ctrl+C)
+        const signal = (execError as { signal?: unknown })?.signal;
+        if (signal === "SIGINT" || signal === "SIGTERM") {
+          return;
+        }
+        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 runCommand = async (command: string, commandArgs: string[]) => {
+      if (captureOutput) {
+        const result = await runAgentWithPty({
+          command,
+          args: commandArgs,
+          cwd: worktreePath,
+          env,
+          agentId: "codex-cli",
+        });
+        if (isNormalExitSignal(result.signal)) {
+          return;
         }
-      };
+        if (result.exitCode !== null && result.exitCode !== 0) {
+          throw new Error(
+            `Codex CLI exited with code ${result.exitCode ?? "unknown"}`,
+          );
+        }
+        return;
+      }
+
+      if (!childStdio) {
+        return;
+      }
 
-      const child = execa("bunx", [CODEX_CLI_PACKAGE, ...args], {
+      const child = execa(command, commandArgs, {
         cwd: worktreePath,
         stdin: childStdio.stdin,
         stdout: childStdio.stdout,
@@ -202,12 +242,50 @@ export async function launchCodexCLI(
         env,
       });
       await execChild(child);
+    };
+
+    // Determine execution strategy based on version selection
+    // FR-063b: "installed" option only appears when local command exists
+    const requestedVersion = options.version ?? "latest";
+    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") {
+      writeTerminalLine(chalk.green(`   📦 Version: installed`));
+    } else {
+      writeTerminalLine(chalk.green(`   📦 Version: @${selectedVersion}`));
+    }
+
+    try {
+      if (selectedVersion === "installed" && codexLookup.path) {
+        // FR-066: Use locally installed command when "installed" is selected
+        // FR-063b guarantees local command exists when this option is shown
+        writeTerminalLine(
+          chalk.green("   ✨ Using locally installed codex command"),
+        );
+        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}`));
+
+        await runCommand("bunx", [packageWithVersion, ...args]);
+      }
     } finally {
-      childStdio.cleanup();
+      childStdio?.cleanup();
     }
 
     // File-based session detection only - no stdout capture
-    // Use only findLatestCodexSession with short timeout, skip sessionProbe to avoid hanging
+    // Use only file inspection with a short wait to avoid hanging
     let capturedSessionId: string | null = null;
     const finishedAt = Date.now();
     try {
@@ -217,6 +295,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.
@@ -226,14 +308,25 @@ export async function launchCodexCLI(
     } catch {
       capturedSessionId = usedExplicitSessionId ? resumeSessionId : null;
     }
+    const shouldSkipWait =
+      typeof process !== "undefined" &&
+      (process.env?.NODE_ENV === "test" || Boolean(process.env?.VITEST));
+    if (!capturedSessionId && !shouldSkipWait) {
+      capturedSessionId = await waitForCodexSessionId({
+        startedAt,
+        timeoutMs: 15_000,
+        pollIntervalMs: 1_000,
+        cwd: worktreePath,
+      });
+    }
 
     if (capturedSessionId) {
-      console.log(chalk.cyan(`\n   🆔 Session ID: ${capturedSessionId}`));
-      console.log(
+      writeTerminalLine(chalk.cyan(`\n   🆔 Session ID: ${capturedSessionId}`));
+      writeTerminalLine(
         chalk.gray(`   Resume command: codex resume ${capturedSessionId}`),
       );
     } else {
-      console.log(
+      writeTerminalLine(
         chalk.yellow(
           "\n   ℹ️  Could not determine Codex session ID automatically.",
         ),
@@ -250,19 +343,25 @@ export async function launchCodexCLI(
         : `Failed to launch Codex CLI: ${details || "Unknown error"}`;
 
     if (platform() === "win32") {
-      console.error(chalk.red("\n💡 Windows troubleshooting tips:"));
-      console.error(
+      writeTerminalLine(
+        chalk.red("\n💡 Windows troubleshooting tips:"),
+        "stderr",
+      );
+      writeTerminalLine(
         chalk.yellow(
           "   1. Confirm that Bun is installed and bunx is available",
         ),
+        "stderr",
       );
-      console.error(
+      writeTerminalLine(
         chalk.yellow(
           '   2. Run "bunx @openai/codex@latest -- --help" to verify the setup',
         ),
+        "stderr",
       );
-      console.error(
+      writeTerminalLine(
         chalk.yellow("   3. Restart your terminal or IDE to refresh PATH"),
+        "stderr",
       );
     }
 
@@ -278,12 +377,12 @@ export async function launchCodexCLI(
  */
 export async function isCodexAvailable(): Promise<boolean> {
   try {
-    await execa("bunx", [CODEX_CLI_PACKAGE, "--help"]);
+    await execa("bunx", [`${CODEX_CLI_PACKAGE}@latest`, "--help"]);
     return true;
   } catch (error: unknown) {
     const err = error as NodeJS.ErrnoException;
     if (err.code === "ENOENT") {
-      console.error(chalk.yellow("\n⚠️  bunx command not found"));
+      writeTerminalLine(chalk.yellow("\n⚠️  bunx command not found"), "stderr");
     }
     return false;
   }

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

@@ -0,0 +1,143 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdir, rm } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+import { saveSession, loadSession } from "../index.js";
+
+describe("saveSession", () => {
+  let testDir: string;
+  let testRepoRoot: string;
+
+  beforeEach(async () => {
+    // Create a unique temporary directory for each test
+    testDir = join(
+      tmpdir(),
+      `gwt-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    testRepoRoot = join(testDir, "test-repo");
+    await mkdir(testRepoRoot, { recursive: true });
+  });
+
+  afterEach(async () => {
+    // Clean up temporary directory
+    try {
+      await rm(testDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  it("should save toolVersion to session history", async () => {
+    // Arrange
+    const sessionData = {
+      lastWorktreePath: testRepoRoot,
+      lastBranch: "feature/test",
+      lastUsedTool: "claude-code",
+      toolLabel: "Claude Code",
+      mode: "normal" as const,
+      model: "opus",
+      reasoningLevel: "high",
+      skipPermissions: false,
+      toolVersion: "2.1.1",
+      timestamp: Date.now(),
+      repositoryRoot: testRepoRoot,
+    };
+
+    // Act
+    await saveSession(sessionData);
+    const loaded = await loadSession(testRepoRoot);
+
+    // Assert
+    expect(loaded).not.toBeNull();
+    expect(loaded?.history).toHaveLength(1);
+    expect(loaded?.history?.[0]?.toolVersion).toBe("2.1.1");
+  });
+
+  it("should save latest toolVersion when not provided", async () => {
+    // Arrange
+    const sessionData = {
+      lastWorktreePath: testRepoRoot,
+      lastBranch: "feature/test",
+      lastUsedTool: "claude-code",
+      toolLabel: "Claude Code",
+      mode: "normal" as const,
+      model: "opus",
+      timestamp: Date.now(),
+      repositoryRoot: testRepoRoot,
+    };
+
+    // Act
+    await saveSession(sessionData);
+    const loaded = await loadSession(testRepoRoot);
+
+    // Assert
+    expect(loaded).not.toBeNull();
+    expect(loaded?.history).toHaveLength(1);
+    expect(loaded?.history?.[0]?.toolVersion).toBe("latest");
+  });
+
+  it("should preserve toolVersion across multiple saves", async () => {
+    // Arrange - first save with version 1.0.0
+    await saveSession({
+      lastWorktreePath: testRepoRoot,
+      lastBranch: "feature/test",
+      lastUsedTool: "claude-code",
+      toolLabel: "Claude Code",
+      toolVersion: "1.0.0",
+      timestamp: Date.now() - 1000,
+      repositoryRoot: testRepoRoot,
+    });
+
+    // Act - second save with version 2.0.0
+    await saveSession({
+      lastWorktreePath: testRepoRoot,
+      lastBranch: "feature/test",
+      lastUsedTool: "claude-code",
+      toolLabel: "Claude Code",
+      toolVersion: "2.0.0",
+      timestamp: Date.now(),
+      repositoryRoot: testRepoRoot,
+    });
+
+    const loaded = await loadSession(testRepoRoot);
+
+    // Assert - should have 2 entries with different versions
+    expect(loaded?.history).toHaveLength(2);
+    // History is stored oldest first (newest at the end)
+    expect(loaded?.history?.[0]?.toolVersion).toBe("1.0.0");
+    expect(loaded?.history?.[1]?.toolVersion).toBe("2.0.0");
+  });
+
+  it("should not add to history when skipHistory is true", async () => {
+    // Arrange - first save
+    await saveSession({
+      lastWorktreePath: testRepoRoot,
+      lastBranch: "feature/test",
+      lastUsedTool: "claude-code",
+      toolLabel: "Claude Code",
+      toolVersion: "1.0.0",
+      timestamp: Date.now(),
+      repositoryRoot: testRepoRoot,
+    });
+
+    // Act - second save with skipHistory
+    await saveSession(
+      {
+        lastWorktreePath: testRepoRoot,
+        lastBranch: "feature/test",
+        lastUsedTool: "claude-code",
+        toolLabel: "Claude Code",
+        toolVersion: "2.0.0",
+        timestamp: Date.now(),
+        repositoryRoot: testRepoRoot,
+      },
+      { skipHistory: true },
+    );
+
+    const loaded = await loadSession(testRepoRoot);
+
+    // Assert - should still have only 1 entry
+    expect(loaded?.history).toHaveLength(1);
+    expect(loaded?.history?.[0]?.toolVersion).toBe("1.0.0");
+  });
+});