@akiojin/gwt 3.1.2 → 4.0.1

package/src/gemini.ts

@@ -1,11 +1,20 @@
 import { execa } from "execa";
 import chalk from "chalk";
 import { existsSync } from "fs";
-import { createChildStdio, getTerminalStreams } from "./utils/terminal.js";
+import {
+  createChildStdio,
+  getTerminalStreams,
+  resetTerminalModes,
+} from "./utils/terminal.js";
+import { isCommandAvailable } from "./utils/command.js";
 import { findLatestGeminiSessionId } from "./utils/session.js";
 
 const GEMINI_CLI_PACKAGE = "@google/gemini-cli@latest";
 
+/**
+ * Error wrapper used by `launchGeminiCLI` to preserve the original failure
+ * while providing a user-friendly message.
+ */
 export class GeminiError extends Error {
   constructor(
     message: string,
@@ -16,6 +25,16 @@ export class GeminiError extends Error {
   }
 }
 
+/**
+ * Launches Gemini CLI in the given worktree path.
+ *
+ * This function resets terminal modes before and after the child process and
+ * supports continue/resume modes when a session id is available.
+ *
+ * @param worktreePath - Worktree directory to run Gemini CLI in
+ * @param options - Launch options (mode/session/model/permissions/env)
+ * @returns Captured session id when available
+ */
 export async function launchGeminiCLI(
   worktreePath: string,
   options: {
@@ -119,6 +138,7 @@ export async function launchGeminiCLI(
       );
     }
     terminal.exitRawMode();
+    resetTerminalModes(terminal.stdout);
 
     const baseEnv = Object.fromEntries(
       Object.entries({
@@ -132,64 +152,43 @@ export async function launchGeminiCLI(
     const childStdio = createChildStdio();
 
     // Auto-detect locally installed gemini command
-    const hasLocalGemini = await isGeminiCommandAvailable();
+    const hasLocalGemini = await isCommandAvailable("gemini");
 
-    // Capture session ID from Gemini's exit summary
+    // Preserve TTY for interactive UI (colors/width) by inheriting stdout/stderr.
+    // Session ID is determined via file-based detection after exit.
     let capturedSessionId: string | null = null;
-    const extractSessionId = (output: string | undefined) => {
-      if (!output) return;
-      // Gemini outputs "Session ID: <uuid>" in exit summary
-      // UUID may be split across lines due to terminal width
-      // First, find "Session ID:" and extract following hex characters
-      const sessionIdIndex = output.indexOf("Session ID:");
-      if (sessionIdIndex === -1) return;
 
-      // Extract text after "Session ID:" until we have enough hex chars for UUID
-      const afterLabel = output.slice(sessionIdIndex + "Session ID:".length);
-      // Remove all non-hex characters except dash, then extract UUID pattern
-      const hexOnly = afterLabel.replace(/[^0-9a-fA-F-]/g, "");
-      // UUID format: 8-4-4-4-12 = 32 hex chars + 4 dashes
-      const uuidMatch = hexOnly.match(
-        /^([0-9a-f]{8})-?([0-9a-f]{4})-?([0-9a-f]{4})-?([0-9a-f]{4})-?([0-9a-f]{12})/i,
-      );
-      if (uuidMatch) {
-        capturedSessionId = `${uuidMatch[1]}-${uuidMatch[2]}-${uuidMatch[3]}-${uuidMatch[4]}-${uuidMatch[5]}`;
-      }
-    };
-
-    const runGemini = async (
-      runArgs: string[],
-    ): Promise<string | undefined> => {
-      // Capture stdout while passing through to terminal
-      // Store chunks to extract session ID after process exits
-      const outputChunks: string[] = [];
+    const runGemini = async (runArgs: string[]): Promise<void> => {
+      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;
+        }
+      };
 
-      const runWithCapture = async (cmd: string, args: string[]) => {
+      const run = async (cmd: string, args: string[]) => {
         const child = execa(cmd, args, {
           cwd: worktreePath,
           shell: true,
           stdin: childStdio.stdin,
-          stdout: "pipe",
+          stdout: childStdio.stdout,
           stderr: childStdio.stderr,
           env: baseEnv,
         });
-
-        // Pass stdout through to terminal while capturing
-        child.stdout?.on("data", (chunk: Buffer) => {
-          const text = chunk.toString("utf8");
-          outputChunks.push(text);
-          terminal.stdout.write(chunk);
-        });
-
-        await child;
-        return outputChunks.join("");
+        await execChild(child);
       };
 
       if (hasLocalGemini) {
         console.log(
           chalk.green("   ✨ Using locally installed gemini command"),
         );
-        return await runWithCapture("gemini", runArgs);
+        return await run("gemini", runArgs);
       }
       console.log(
         chalk.cyan("   🔄 Falling back to bunx @google/gemini-cli@latest"),
@@ -202,15 +201,14 @@ export async function launchGeminiCLI(
       console.log(chalk.yellow("      npm install -g @google/gemini-cli"));
       console.log("");
       await new Promise((resolve) => setTimeout(resolve, 2000));
-      return await runWithCapture("bunx", [GEMINI_CLI_PACKAGE, ...runArgs]);
+      return await run("bunx", [GEMINI_CLI_PACKAGE, ...runArgs]);
     };
 
-    let output: string | undefined;
     let fellBackToLatest = false;
     try {
       // Try with explicit session ID first (if any), then fallback to --resume (latest) once
       try {
-        output = await runGemini(argsPrimary);
+        await runGemini(argsPrimary);
       } catch (err) {
         const shouldRetry =
           (options.mode === "resume" || options.mode === "continue") &&
@@ -222,7 +220,7 @@ export async function launchGeminiCLI(
               `   ⚠️  Failed to resume session ${resumeSessionId}. Retrying with latest session...`,
             ),
           );
-          output = await runGemini(argsFallback);
+          await runGemini(argsFallback);
         } else {
           throw err;
         }
@@ -231,9 +229,6 @@ export async function launchGeminiCLI(
       childStdio.cleanup();
     }
 
-    // Extract session ID from Gemini's exit summary output
-    extractSessionId(output);
-
     const explicitResumeSucceeded = usedExplicitSessionId && !fellBackToLatest;
 
     // If we explicitly resumed a specific session (and did not fall back), keep that ID.
@@ -268,7 +263,7 @@ export async function launchGeminiCLI(
 
     return capturedSessionId ? { sessionId: capturedSessionId } : {};
   } catch (error: unknown) {
-    const hasLocalGemini = await isGeminiCommandAvailable();
+    const hasLocalGemini = await isCommandAvailable("gemini");
     let errorMessage: string;
     const err = error as NodeJS.ErrnoException;
 
@@ -316,29 +311,13 @@ export async function launchGeminiCLI(
     throw new GeminiError(errorMessage, error);
   } finally {
     terminal.exitRawMode();
+    resetTerminalModes(terminal.stdout);
   }
 }
 
 /**
- * Check if locally installed `gemini` command is available
- * @returns true if `gemini` command exists in PATH, false otherwise
+ * Checks whether Gemini CLI is available via `bunx` in the current environment.
  */
-async function isGeminiCommandAvailable(): Promise<boolean> {
-  try {
-    const command = process.platform === "win32" ? "where" : "which";
-    await execa(command, ["gemini"], {
-      shell: true,
-      stdin: "ignore",
-      stdout: "ignore",
-      stderr: "ignore",
-    });
-    return true;
-  } catch {
-    // gemini command not found in PATH
-    return false;
-  }
-}
-
 export async function isGeminiCLIAvailable(): Promise<boolean> {
   try {
     await execa("bunx", [GEMINI_CLI_PACKAGE, "--version"], { shell: true });

package/src/index.ts

@@ -16,7 +16,6 @@ import {
   type CodexReasoningEffort,
 } from "./codex.js";
 import { launchGeminiCLI, GeminiError } from "./gemini.js";
-import { launchQwenCLI, QwenError } from "./qwen.js";
 import {
   WorktreeOrchestrator,
   type EnsureWorktreeOptions,
@@ -117,7 +116,6 @@ function isRecoverableError(error: unknown): boolean {
     error instanceof WorktreeError ||
     error instanceof CodexError ||
     error instanceof GeminiError ||
-    error instanceof QwenError ||
     error instanceof DependencyInstallError
   ) {
     return true;
@@ -129,7 +127,6 @@ function isRecoverableError(error: unknown): boolean {
       error.name === "WorktreeError" ||
       error.name === "CodexError" ||
       error.name === "GeminiError" ||
-      error.name === "QwenError" ||
       error.name === "DependencyInstallError"
     );
   }
@@ -144,7 +141,6 @@ function isRecoverableError(error: unknown): boolean {
       name === "WorktreeError" ||
       name === "CodexError" ||
       name === "GeminiError" ||
-      name === "QwenError" ||
       name === "DependencyInstallError"
     );
   }
@@ -658,28 +654,6 @@ export async function handleAIToolWorkflow(
         launchOptions.model = model;
       }
       launchResult = await launchGeminiCLI(worktreePath, launchOptions);
-    } else if (tool === "qwen-cli") {
-      const launchOptions: {
-        mode?: "normal" | "continue" | "resume";
-        skipPermissions?: boolean;
-        envOverrides?: Record<string, string>;
-        model?: string;
-        sessionId?: string | null;
-      } = {
-        mode:
-          mode === "resume"
-            ? "resume"
-            : mode === "continue"
-              ? "continue"
-              : "normal",
-        skipPermissions,
-        envOverrides: sharedEnv,
-        sessionId: resumeSessionId,
-      };
-      if (model) {
-        launchOptions.model = model;
-      }
-      launchResult = await launchQwenCLI(worktreePath, launchOptions);
     } else {
       // Custom tool
       printInfo(`Launching custom tool: ${toolConfig.displayName}`);

package/src/utils/command.ts

@@ -0,0 +1,26 @@
+import { execa } from "execa";
+
+/**
+ * Checks whether a command is available in the current PATH.
+ *
+ * Uses `where` on Windows and `which` on other platforms.
+ *
+ * @param commandName - Command name to look up (e.g. `claude`, `npx`, `gemini`)
+ * @returns true if the command exists in PATH
+ */
+export async function isCommandAvailable(
+  commandName: string,
+): Promise<boolean> {
+  try {
+    const command = process.platform === "win32" ? "where" : "which";
+    await execa(command, [commandName], {
+      shell: true,
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/utils/session/index.ts

@@ -5,7 +5,6 @@
  * - Claude Code
  * - Codex CLI
  * - Gemini CLI
- * - Qwen CLI
  */
 
 // Type exports
@@ -41,6 +40,3 @@ export {
   findLatestGeminiSession,
   findLatestGeminiSessionId,
 } from "./parsers/gemini.js";
-
-// Qwen CLI parser
-export { findLatestQwenSessionId } from "./parsers/qwen.js";

package/src/utils/session/parsers/index.ts

@@ -23,6 +23,3 @@ export {
   findLatestGeminiSession,
   findLatestGeminiSessionId,
 } from "./gemini.js";
-
-// Qwen CLI
-export { findLatestQwenSessionId } from "./qwen.js";

package/src/utils/session.ts

@@ -11,7 +11,6 @@
  * - ./session/parsers/claude.js - Claude-specific functions
  * - ./session/parsers/codex.js - Codex-specific functions
  * - ./session/parsers/gemini.js - Gemini-specific functions
- * - ./session/parsers/qwen.js - Qwen-specific functions
  */
 
 export * from "./session/index.js";

package/src/utils/terminal.ts

@@ -2,6 +2,13 @@ import fs from "node:fs";
 import { platform } from "node:os";
 import { ReadStream, WriteStream } from "node:tty";
 
+/**
+ * Terminal streams used by the CLI (stdin/stdout/stderr) and their raw-mode
+ * teardown helper.
+ *
+ * When the current process is not a TTY, this may fall back to `/dev/tty` so
+ * interactive child processes can still read/write correctly.
+ */
 export interface TerminalStreams {
   stdin: NodeJS.ReadStream;
   stdout: NodeJS.WriteStream;
@@ -14,9 +21,18 @@ export interface TerminalStreams {
 }
 
 const DEV_TTY_PATH = "/dev/tty";
+// 端末モードのリセット:
+// - ESC[?1l: application cursor keys (DECCKM) を無効化
+// - ESC>: keypad mode を normal/numeric に戻す
+// WSL2/Windowsの矢印キー入力が壊れるケースを抑止する。
+const TERMINAL_RESET_SEQUENCE = "\u001b[?1l\u001b>";
 
 let cachedStreams: TerminalStreams | null = null;
 
+/**
+ * Stdio configuration for launching an interactive child process (via `execa`),
+ * plus a cleanup hook to be called after the child exits.
+ */
 export interface ChildStdio {
   stdin: "inherit" | { file: string; append?: boolean };
   stdout: "inherit" | { file: string; append?: boolean };
@@ -165,6 +181,9 @@ function createTerminalStreams(): TerminalStreams {
   }
 }
 
+/**
+ * Returns cached terminal streams and falls back to `/dev/tty` when needed.
+ */
 export function getTerminalStreams(): TerminalStreams {
   if (!cachedStreams) {
     cachedStreams = createTerminalStreams();
@@ -172,6 +191,35 @@ export function getTerminalStreams(): TerminalStreams {
   return cachedStreams;
 }
 
+/**
+ * Best-effort terminal mode reset for interactive sessions.
+ *
+ * This writes a small ANSI sequence to restore cursor-key/keypad modes, which
+ * helps prevent broken arrow-key behavior on some Windows/WSL2 terminals after
+ * interactive CLIs exit.
+ */
+export function resetTerminalModes(
+  stdout: NodeJS.WriteStream | undefined,
+): void {
+  if (!stdout || typeof stdout.write !== "function") {
+    return;
+  }
+  if (!("isTTY" in stdout) || !stdout.isTTY) {
+    return;
+  }
+  try {
+    stdout.write(TERMINAL_RESET_SEQUENCE);
+  } catch {
+    // Ignore terminal reset errors.
+  }
+}
+
+/**
+ * Creates stdio settings for launching a child process.
+ *
+ * When terminal streams are backed by `/dev/tty`, forwards those file
+ * descriptors to the child so it remains interactive.
+ */
 export function createChildStdio(): ChildStdio {
   const terminal = getTerminalStreams();
 
@@ -196,6 +244,12 @@ function isInteractive(stream: NodeJS.ReadStream): boolean {
   return Boolean(stream.isTTY);
 }
 
+/**
+ * Prints a message and waits for the user to press Enter when running in an
+ * interactive terminal.
+ *
+ * Useful for pausing on errors while ensuring raw mode is disabled.
+ */
 export async function waitForUserAcknowledgement(
   message: string = DEFAULT_ACK_MESSAGE,
 ): Promise<void> {
@@ -214,20 +268,26 @@ export async function waitForUserAcknowledgement(
   terminal.exitRawMode();
 
   await new Promise<void>((resolve) => {
-    const cleanup = () => {
+    let finished = false;
+
+    function cleanup(): void {
+      if (finished) {
+        return;
+      }
+      finished = true;
       stdin.removeListener("data", onData);
       if (typeof stdin.pause === "function") {
         stdin.pause();
       }
-    };
+    }
 
-    const onData = (chunk: Buffer | string) => {
+    function onData(chunk: Buffer | string): void {
       const data = typeof chunk === "string" ? chunk : chunk.toString("utf8");
       if (data.includes("\n") || data.includes("\r")) {
         cleanup();
         resolve();
       }
-    };
+    }
 
     if (typeof stdout?.write === "function") {
       stdout.write(`\n${message}\n`);
@@ -238,5 +298,6 @@ export async function waitForUserAcknowledgement(
     }
 
     stdin.on("data", onData);
+    process.once("exit", cleanup);
   });
 }

package/src/web/client/src/components/branch-detail/BranchInfoCards.tsx

@@ -13,7 +13,6 @@ function mapToolLabel(toolId: string, toolLabel?: string | null): string {
   if (toolId === "claude-code") return "Claude";
   if (toolId === "codex-cli") return "Codex";
   if (toolId === "gemini-cli") return "Gemini";
-  if (toolId === "qwen-cli") return "Qwen";
   if (toolLabel) return toolLabel;
   return "Custom";
 }

package/dist/qwen.d.ts

@@ -1,16 +0,0 @@
-export declare class QwenError extends Error {
-    cause?: unknown | undefined;
-    constructor(message: string, cause?: unknown | undefined);
-}
-export declare function launchQwenCLI(worktreePath: string, options?: {
-    skipPermissions?: boolean;
-    mode?: "normal" | "continue" | "resume";
-    extraArgs?: string[];
-    envOverrides?: Record<string, string>;
-    model?: string;
-    sessionId?: string | null;
-}): Promise<{
-    sessionId?: string | null;
-}>;
-export declare function isQwenCLIAvailable(): Promise<boolean>;
-//# sourceMappingURL=qwen.d.ts.map

package/dist/qwen.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"qwen.d.ts","sourceRoot":"","sources":["../src/qwen.ts"],"names":[],"mappings":"AAQA,qBAAa,SAAU,SAAQ,KAAK;IAGzB,KAAK,CAAC,EAAE,OAAO;gBADtB,OAAO,EAAE,MAAM,EACR,KAAK,CAAC,EAAE,OAAO,YAAA;CAKzB;AAED,wBAAsB,aAAa,CACjC,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE;IACP,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,IAAI,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAC;IACxC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,GACL,OAAO,CAAC;IAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAmNxC;AAiBD,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,OAAO,CAAC,CAgB3D"}