@akiojin/gwt 4.1.1 → 4.3.0

package/src/services/aiToolResolver.ts

@@ -1,12 +1,16 @@
 import { execa } from "execa";
 import { platform } from "os";
 import { getToolById } from "../config/tools.js";
+import { CLAUDE_CODE_TOOL } from "../config/builtin-tools.js";
 import {
   CODEX_DEFAULT_ARGS,
   CLAUDE_PERMISSION_SKIP_ARGS,
 } from "../shared/aiToolConstants.js";
 import { prepareCustomToolExecution } from "./customToolResolver.js";
 import type { LaunchOptions } from "../types/tools.js";
+import { createLogger } from "../logging/logger.js";
+
+const logger = createLogger({ category: "resolver" });
 
 const DETECTION_COMMAND = platform() === "win32" ? "where" : "which";
 const MIN_BUN_MAJOR = 1;
@@ -41,12 +45,32 @@ export class AIToolResolutionError extends Error {
 async function commandExists(command: string): Promise<boolean> {
   try {
     await execa(DETECTION_COMMAND, [command], { shell: true });
+    logger.debug({ command, exists: true }, "Command check");
     return true;
   } catch {
+    logger.debug({ command, exists: false }, "Command check");
     return false;
   }
 }
 
+/**
+ * コマンドのフルパスを取得
+ * node-ptyはシェルを経由しないため、フルパスが必要
+ */
+async function resolveCommandPath(command: string): Promise<string | null> {
+  try {
+    const { stdout } = await execa(DETECTION_COMMAND, [command], {
+      shell: true,
+    });
+    const fullPath = stdout.trim().split("\n")[0];
+    logger.debug({ command, fullPath }, "Command path resolved");
+    return fullPath || null;
+  } catch {
+    logger.debug({ command, fullPath: null }, "Command path resolution failed");
+    return null;
+  }
+}
+
 let bunxCheckPromise: Promise<void> | null = null;
 
 async function ensureBunxAvailable(): Promise<void> {
@@ -67,6 +91,7 @@ async function ensureBunxAvailable(): Promise<void> {
       try {
         const { stdout } = await execa("bun", ["--version"]);
         const version = stdout.trim();
+        logger.debug({ bunVersion: version }, "Bun version detected");
         const major = parseInt(version.split(".")[0] ?? "0", 10);
         if (!Number.isFinite(major) || major < MIN_BUN_MAJOR) {
           throw new AIToolResolutionError(
@@ -144,20 +169,40 @@ export async function resolveClaudeCommand(
   options: ClaudeCommandOptions = {},
 ): Promise<ResolvedCommand> {
   const args = buildClaudeArgs(options);
-
-  if (await commandExists("claude")) {
+  const envOverrides = CLAUDE_CODE_TOOL.env
+    ? { env: { ...CLAUDE_CODE_TOOL.env } as NodeJS.ProcessEnv }
+    : {};
+
+  // フルパスを取得（node-ptyはシェルを経由しないため必要）
+  const claudePath = await resolveCommandPath("claude");
+  if (claudePath) {
+    logger.info(
+      { command: claudePath, usesFallback: false },
+      "Claude command resolved",
+    );
     return {
-      command: "claude",
+      command: claudePath,
       args,
       usesFallback: false,
+      ...envOverrides,
     };
   }
 
-  await ensureBunxAvailable();
+  // bunxへフォールバック
+  const bunxPath = await resolveCommandPath("bunx");
+  if (!bunxPath) {
+    await ensureBunxAvailable(); // エラーをスローする
+  }
+
+  logger.info(
+    { command: bunxPath ?? "bunx", usesFallback: true },
+    "Claude command resolved (fallback)",
+  );
   return {
-    command: "bunx",
+    command: bunxPath ?? "bunx",
     args: [CLAUDE_CLI_PACKAGE, ...args],
     usesFallback: true,
+    ...envOverrides,
   };
 }
 
@@ -198,17 +243,32 @@ export async function resolveCodexCommand(
 ): Promise<ResolvedCommand> {
   const args = buildCodexArgs(options);
 
-  if (await commandExists("codex")) {
+  // フルパスを取得（node-ptyはシェルを経由しないため必要）
+  const codexPath = await resolveCommandPath("codex");
+  if (codexPath) {
+    logger.info(
+      { command: codexPath, usesFallback: false },
+      "Codex command resolved",
+    );
     return {
-      command: "codex",
+      command: codexPath,
       args,
       usesFallback: false,
     };
   }
 
-  await ensureBunxAvailable();
+  // bunxへフォールバック
+  const bunxPath = await resolveCommandPath("bunx");
+  if (!bunxPath) {
+    await ensureBunxAvailable(); // エラーをスローする
+  }
+
+  logger.info(
+    { command: bunxPath ?? "bunx", usesFallback: true },
+    "Codex command resolved (fallback)",
+  );
   return {
-    command: "bunx",
+    command: bunxPath ?? "bunx",
     args: [CODEX_CLI_PACKAGE, ...args],
     usesFallback: true,
   };
@@ -223,6 +283,7 @@ export async function resolveCustomToolCommand(
 ): Promise<ResolvedCommand> {
   const tool = await getToolById(options.toolId);
   if (!tool) {
+    logger.error({ toolId: options.toolId }, "Custom tool not found");
     throw new AIToolResolutionError(
       "CUSTOM_TOOL_NOT_FOUND",
       `Custom tool not found: ${options.toolId}`,
@@ -235,6 +296,11 @@ export async function resolveCustomToolCommand(
 
   const execution = await prepareCustomToolExecution(tool, options);
 
+  logger.info(
+    { toolId: options.toolId, command: execution.command },
+    "Custom tool command resolved",
+  );
+
   return {
     command: execution.command,
     args: execution.args,

package/src/services/customToolResolver.ts

@@ -1,5 +1,8 @@
 import { execa } from "execa";
 import type { CustomAITool, LaunchOptions } from "../types/tools.js";
+import { createLogger } from "../logging/logger.js";
+
+const logger = createLogger({ category: "custom-resolver" });
 
 export interface CustomToolExecutionPlan {
   command: string;
@@ -21,6 +24,7 @@ export async function resolveCommandPath(commandName: string): Promise<string> {
       );
     }
 
+    logger.debug({ commandName, resolvedPath }, "Command path resolved");
     return resolvedPath;
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
@@ -55,6 +59,10 @@ export function buildCustomToolArgs(
     args.push(...options.extraArgs);
   }
 
+  logger.debug(
+    { toolId: tool.id, argsCount: args.length },
+    "Custom tool args built",
+  );
   return args;
 }
 
@@ -62,37 +70,44 @@ export async function prepareCustomToolExecution(
   tool: CustomAITool,
   options: LaunchOptions = {},
 ): Promise<CustomToolExecutionPlan> {
-  const args = buildCustomToolArgs(tool, options);
+  const baseArgs = buildCustomToolArgs(tool, options);
   const envOverrides: NodeJS.ProcessEnv | undefined = tool.env
     ? ({ ...tool.env } as NodeJS.ProcessEnv)
     : undefined;
 
+  let command: string;
+  let args: string[];
+
   switch (tool.type) {
     case "path": {
-      return {
-        command: tool.command,
-        args,
-        ...(envOverrides ? { env: envOverrides } : {}),
-      };
+      command = tool.command;
+      args = baseArgs;
+      break;
     }
     case "bunx": {
-      return {
-        command: "bunx",
-        args: [tool.command, ...args],
-        ...(envOverrides ? { env: envOverrides } : {}),
-      };
+      command = "bunx";
+      args = [tool.command, ...baseArgs];
+      break;
     }
     case "command": {
-      const resolved = await resolveCommandPath(tool.command);
-      return {
-        command: resolved,
-        args,
-        ...(envOverrides ? { env: envOverrides } : {}),
-      };
+      command = await resolveCommandPath(tool.command);
+      args = baseArgs;
+      break;
     }
     default: {
       const exhaustive: never = tool.type;
       throw new Error(`Unknown custom tool type: ${exhaustive as string}`);
     }
   }
+
+  logger.debug(
+    { toolId: tool.id, toolType: tool.type, command, hasEnv: !!envOverrides },
+    "Custom tool execution prepared",
+  );
+
+  return {
+    command,
+    args,
+    ...(envOverrides ? { env: envOverrides } : {}),
+  };
 }

package/src/utils/__tests__/prompt.test.ts

@@ -1,5 +1,5 @@
 import { PassThrough } from "node:stream";
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it, vi, beforeEach } from "vitest";
 
 // Shared mock target to avoid hoisting issues
 const terminalStreams: Record<string, unknown> = {};
@@ -16,16 +16,32 @@ const withTimeout = <T>(promise: Promise<T>, ms = 500): Promise<T> =>
     ),
   ]);
 
+const resetTerminalStreams = () => {
+  vi.resetModules();
+  for (const key of Object.keys(terminalStreams)) {
+    delete terminalStreams[key];
+  }
+};
+
+const setupTerminalStreams = (isTTY: boolean) => {
+  const stdin = new PassThrough() as unknown as NodeJS.ReadStream;
+  const stdout = new PassThrough() as unknown as NodeJS.WriteStream;
+  Object.defineProperty(stdin, "isTTY", { value: isTTY, configurable: true });
+  const exitRawMode = vi.fn();
+  Object.assign(terminalStreams, {
+    stdin,
+    stdout,
+    stderr: stdout,
+    usingFallback: false,
+    exitRawMode,
+  });
+  return { stdin, stdout, exitRawMode };
+};
+
 describe("waitForEnter", () => {
   it("uses terminal stdin/stdout and resolves after newline on TTY", async () => {
-    vi.resetModules();
-    for (const key of Object.keys(terminalStreams)) {
-      delete terminalStreams[key];
-    }
-
-    const stdin = new PassThrough() as unknown as NodeJS.ReadStream;
-    const stdout = new PassThrough() as unknown as NodeJS.WriteStream;
-    Object.defineProperty(stdin, "isTTY", { value: true });
+    resetTerminalStreams();
+    const { stdin, exitRawMode } = setupTerminalStreams(true);
 
     let resumed = false;
     let paused = false;
@@ -41,16 +57,6 @@ describe("waitForEnter", () => {
       return originalPause();
     }) as typeof stdin.pause;
 
-    const exitRawMode = vi.fn();
-
-    Object.assign(terminalStreams, {
-      stdin,
-      stdout,
-      stderr: stdout,
-      usingFallback: false,
-      exitRawMode,
-    });
-
     const { waitForEnter } = await import("../prompt.js");
 
     const waiting = withTimeout(waitForEnter("prompt"), 200);
@@ -63,22 +69,8 @@ describe("waitForEnter", () => {
   });
 
   it("returns immediately on non-TTY stdin", async () => {
-    vi.resetModules();
-    for (const key of Object.keys(terminalStreams)) {
-      delete terminalStreams[key];
-    }
-
-    const stdin = new PassThrough() as unknown as NodeJS.ReadStream;
-    const stdout = new PassThrough() as unknown as NodeJS.WriteStream;
-    Object.defineProperty(stdin, "isTTY", { value: false });
-
-    Object.assign(terminalStreams, {
-      stdin,
-      stdout,
-      stderr: stdout,
-      usingFallback: false,
-      exitRawMode: vi.fn(),
-    });
+    resetTerminalStreams();
+    setupTerminalStreams(false);
 
     const { waitForEnter } = await import("../prompt.js");
 
@@ -87,3 +79,48 @@ describe("waitForEnter", () => {
     expect(Date.now() - start).toBeLessThan(50);
   });
 });
+
+describe("confirmYesNo", () => {
+  let stdin: NodeJS.ReadStream;
+  let exitRawMode: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    resetTerminalStreams();
+    const setup = setupTerminalStreams(true);
+    stdin = setup.stdin;
+    exitRawMode = setup.exitRawMode;
+  });
+
+  it("resolves true when user inputs y on TTY", async () => {
+    const { confirmYesNo } = await import("../prompt.js");
+
+    const waiting = withTimeout(confirmYesNo("push?"), 200);
+    stdin.write("y\n");
+
+    await expect(waiting).resolves.toBe(true);
+    expect(exitRawMode).toHaveBeenCalled();
+  });
+
+  it("uses default value when input is empty on TTY", async () => {
+    const { confirmYesNo } = await import("../prompt.js");
+
+    const waiting = withTimeout(
+      confirmYesNo("push?", { defaultValue: true }),
+      200,
+    );
+    stdin.write("\n");
+
+    await expect(waiting).resolves.toBe(true);
+  });
+
+  it("returns default immediately on non-TTY stdin", async () => {
+    Object.defineProperty(stdin, "isTTY", { value: false });
+
+    const { confirmYesNo } = await import("../prompt.js");
+
+    const start = Date.now();
+    const result = await confirmYesNo("push?", { defaultValue: false });
+    expect(result).toBe(false);
+    expect(Date.now() - start).toBeLessThan(50);
+  });
+});

package/src/utils/prompt.ts

@@ -1,17 +1,26 @@
 import readline from "node:readline";
 import { getTerminalStreams } from "./terminal.js";
 
-/**
- * Wait for Enter using the same terminal streams as Ink.
- * Falls back to no-op on non-interactive stdin to avoid blocking pipelines.
- */
-export async function waitForEnter(promptMessage: string): Promise<void> {
+type ReadlinePromptOptions<T> = {
+  fallback: T;
+  onAnswer: (answer: string) => T | undefined;
+  shouldSkip?: (terminal: ReturnType<typeof getTerminalStreams>) => boolean;
+};
+
+async function runReadlinePrompt<T>(
+  promptText: string,
+  { fallback, onAnswer, shouldSkip }: ReadlinePromptOptions<T>,
+): Promise<T> {
   const terminal = getTerminalStreams();
   const stdin = terminal.stdin as NodeJS.ReadStream | undefined;
   const stdout = terminal.stdout as NodeJS.WriteStream | undefined;
 
   if (!stdin || typeof stdin.on !== "function" || !stdin.isTTY) {
-    return;
+    return fallback;
+  }
+
+  if (shouldSkip?.(terminal)) {
+    return fallback;
   }
 
   terminal.exitRawMode?.();
@@ -30,10 +39,15 @@ export async function waitForEnter(promptMessage: string): Promise<void> {
     }
   }
 
-  await new Promise<void>((resolve) => {
+  return new Promise<T>((resolve) => {
     const rl = readline.createInterface({ input: stdin, output: stdout });
+    let finished = false;
 
     const cleanup = () => {
+      if (finished) {
+        return;
+      }
+      finished = true;
       rl.removeAllListeners();
       rl.close();
       const remover = (method: "off" | "removeListener") =>
@@ -61,7 +75,7 @@ export async function waitForEnter(promptMessage: string): Promise<void> {
 
     const onEnd = () => {
       cleanup();
-      resolve();
+      resolve(fallback);
     };
 
     rl.on("SIGINT", () => {
@@ -69,12 +83,67 @@ export async function waitForEnter(promptMessage: string): Promise<void> {
       process.exit(0);
     });
 
-    rl.question(`${promptMessage}\n`, () => {
+    rl.question(`${promptText}\n`, (answer) => {
+      const result = onAnswer(answer);
       cleanup();
-      resolve();
+      resolve(result !== undefined ? result : fallback);
     });
 
     stdin.once("end", onEnd);
     stdin.once("error", onEnd);
   });
 }
+
+/**
+ * Wait for Enter using the same terminal streams as Ink.
+ * Falls back to no-op on non-interactive stdin to avoid blocking pipelines.
+ */
+export async function waitForEnter(promptMessage: string): Promise<void> {
+  await runReadlinePrompt(promptMessage, {
+    fallback: undefined,
+    onAnswer: () => undefined,
+  });
+}
+
+/**
+ * Prompts the user for a yes/no confirmation in the terminal.
+ * Falls back to the default value on non-interactive stdin or fallback terminals.
+ *
+ * @param promptMessage - The message to display to the user
+ * @param options - Configuration options
+ * @param options.defaultValue - The default value when input is empty or stdin is non-interactive
+ * @returns A promise that resolves to true for yes, false for no
+ */
+export async function confirmYesNo(
+  promptMessage: string,
+  options: { defaultValue?: boolean } = {},
+): Promise<boolean> {
+  const fallback = options.defaultValue ?? false;
+
+  const suffix =
+    options.defaultValue === undefined
+      ? "[y/n]"
+      : options.defaultValue
+        ? "[Y/n]"
+        : "[y/N]";
+
+  const promptText = `${promptMessage} ${suffix}`.trim();
+
+  return runReadlinePrompt(promptText, {
+    fallback,
+    shouldSkip: (terminal) => terminal.usingFallback,
+    onAnswer: (answer) => {
+      const normalized = answer.trim().toLowerCase();
+      if (normalized === "y" || normalized === "yes") {
+        return true;
+      }
+      if (normalized === "n" || normalized === "no") {
+        return false;
+      }
+      if (normalized.length === 0 && options.defaultValue !== undefined) {
+        return options.defaultValue;
+      }
+      return undefined;
+    },
+  });
+}

package/src/utils/webui.ts

@@ -2,7 +2,7 @@ import * as net from "node:net";
 
 export function resolveWebUiPort(
   portEnv: string | undefined = process.env.PORT,
-  defaultPort = 3000,
+  defaultPort = 3001,
 ): number {
   if (!portEnv) {
     return defaultPort;