@akiojin/gwt 2.13.0 → 2.14.0

package/src/logging/logger.ts

@@ -17,7 +17,7 @@ export interface LoggerConfig {
   sync?: boolean;
 }
 
-/** 
+/**
  * Create a pino logger with unified structure and category field.
  * - Writes to a single file stream (no per-component files)
  * - Adds `category` to each log record
@@ -51,7 +51,10 @@ export function createLogger(config: LoggerConfig = {}): Logger {
   };
 
   if (config.sync) {
-    const destinationStream = pino.destination({ dest: destination, sync: true });
+    const destinationStream = pino.destination({
+      dest: destination,
+      sync: true,
+    });
     return pino(options, destinationStream);
   }
 

package/src/qwen.ts

@@ -52,6 +52,9 @@ export async function launchQwenCLI(
       options.sessionId && options.sessionId.trim().length > 0
         ? options.sessionId.trim()
         : null;
+    const usedExplicitSessionId =
+      Boolean(resumeSessionId) &&
+      (options.mode === "continue" || options.mode === "resume");
     switch (options.mode) {
       case "continue":
         console.log(
@@ -94,10 +97,14 @@ export async function launchQwenCLI(
 
     terminal.exitRawMode();
 
-    const baseEnv = {
-      ...process.env,
-      ...(options.envOverrides ?? {}),
-    };
+    const baseEnv = Object.fromEntries(
+      Object.entries({
+        ...process.env,
+        ...(options.envOverrides ?? {}),
+      }).filter(
+        (entry): entry is [string, string] => typeof entry[1] === "string",
+      ),
+    );
 
     const childStdio = createChildStdio();
 
@@ -105,12 +112,13 @@ export async function launchQwenCLI(
     const hasLocalQwen = await isQwenCommandAvailable();
 
     try {
-      const execChild = async (child: any) => {
+      const execChild = async (child: Promise<unknown>) => {
         try {
           await child;
-        } catch (execError: any) {
+        } catch (execError: unknown) {
           // Treat SIGINT/SIGTERM as normal exit (user pressed Ctrl+C)
-          if (execError.signal === "SIGINT" || execError.signal === "SIGTERM") {
+          const signal = (execError as { signal?: unknown })?.signal;
+          if (signal === "SIGINT" || signal === "SIGTERM") {
             return;
           }
           throw execError;
@@ -127,7 +135,7 @@ export async function launchQwenCLI(
           stdout: childStdio.stdout,
           stderr: childStdio.stderr,
           env: baseEnv,
-        } as any);
+        });
         await execChild(child);
       } else {
         // Fallback to bunx
@@ -150,7 +158,7 @@ export async function launchQwenCLI(
           stdout: childStdio.stdout,
           stderr: childStdio.stderr,
           env: baseEnv,
-        } as any);
+        });
         await execChild(child);
       }
     } finally {
@@ -159,12 +167,10 @@ export async function launchQwenCLI(
 
     let capturedSessionId: string | null = null;
     try {
-      capturedSessionId =
-        (await findLatestQwenSessionId(worktreePath)) ??
-        resumeSessionId ??
-        null;
+      const detected = (await findLatestQwenSessionId(worktreePath)) ?? null;
+      capturedSessionId = usedExplicitSessionId ? resumeSessionId : detected;
     } catch {
-      capturedSessionId = resumeSessionId ?? null;
+      capturedSessionId = usedExplicitSessionId ? resumeSessionId : null;
     }
 
     if (capturedSessionId) {
@@ -181,11 +187,12 @@ export async function launchQwenCLI(
     }
 
     return capturedSessionId ? { sessionId: capturedSessionId } : {};
-  } catch (error: any) {
+  } catch (error: unknown) {
     const hasLocalQwen = await isQwenCommandAvailable();
     let errorMessage: string;
+    const err = error as NodeJS.ErrnoException;
 
-    if (error.code === "ENOENT") {
+    if (err.code === "ENOENT") {
       if (hasLocalQwen) {
         errorMessage =
           "qwen command not found. Please ensure Qwen CLI is properly installed.";
@@ -194,7 +201,8 @@ export async function launchQwenCLI(
           "bunx command not found. Please ensure Bun is installed so Qwen CLI can run via bunx.";
       }
     } else {
-      errorMessage = `Failed to launch Qwen CLI: ${error.message || "Unknown error"}`;
+      const details = error instanceof Error ? error.message : String(error);
+      errorMessage = `Failed to launch Qwen CLI: ${details || "Unknown error"}`;
     }
 
     if (process.platform === "win32") {
@@ -250,8 +258,9 @@ export async function isQwenCLIAvailable(): Promise<boolean> {
   try {
     await execa("bunx", [QWEN_CLI_PACKAGE, "--version"], { shell: true });
     return true;
-  } catch (error: any) {
-    if (error.code === "ENOENT") {
+  } catch (error: unknown) {
+    const err = error as NodeJS.ErrnoException;
+    if (err.code === "ENOENT") {
       console.error(chalk.yellow("\n⚠️  bunx command not found"));
       console.error(
         chalk.gray(

package/src/services/aiToolResolver.ts

@@ -0,0 +1,276 @@
+import { execa } from "execa";
+import { platform } from "os";
+import { getToolById } from "../config/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";
+
+const DETECTION_COMMAND = platform() === "win32" ? "where" : "which";
+const MIN_BUN_MAJOR = 1;
+
+export const CLAUDE_CLI_PACKAGE = "@anthropic-ai/claude-code@latest";
+export const CODEX_CLI_PACKAGE = "@openai/codex@latest";
+
+export type ResolverErrorCode =
+  | "COMMAND_NOT_FOUND"
+  | "BUNX_NOT_FOUND"
+  | "BUN_TOO_OLD"
+  | "CUSTOM_TOOL_NOT_FOUND";
+
+export interface ResolvedCommand {
+  command: string;
+  args: string[];
+  usesFallback: boolean;
+  env?: NodeJS.ProcessEnv;
+}
+
+export class AIToolResolutionError extends Error {
+  constructor(
+    public code: ResolverErrorCode,
+    message: string,
+    public hints?: string[],
+  ) {
+    super(message);
+    this.name = "AIToolResolutionError";
+  }
+}
+
+async function commandExists(command: string): Promise<boolean> {
+  try {
+    await execa(DETECTION_COMMAND, [command], { shell: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+let bunxCheckPromise: Promise<void> | null = null;
+
+async function ensureBunxAvailable(): Promise<void> {
+  if (!bunxCheckPromise) {
+    bunxCheckPromise = (async () => {
+      const bunxExists = await commandExists("bunx");
+      if (!bunxExists) {
+        throw new AIToolResolutionError(
+          "BUNX_NOT_FOUND",
+          "bunx command not found. Install Bun 1.0+ so bunx is available on PATH.",
+          [
+            "Install Bun: https://bun.sh/docs/installation",
+            "After installation, restart your terminal so bunx is on PATH.",
+          ],
+        );
+      }
+
+      try {
+        const { stdout } = await execa("bun", ["--version"]);
+        const version = stdout.trim();
+        const major = parseInt(version.split(".")[0] ?? "0", 10);
+        if (!Number.isFinite(major) || major < MIN_BUN_MAJOR) {
+          throw new AIToolResolutionError(
+            "BUN_TOO_OLD",
+            `Detected Bun ${version}. Bun ${MIN_BUN_MAJOR}.0+ is required for bunx fallback execution.`,
+            [
+              "Upgrade Bun: curl -fsSL https://bun.sh/install | bash",
+              "Verify with 'bun --version' (needs >= 1.0)",
+            ],
+          );
+        }
+      } catch (error: unknown) {
+        if (error instanceof AIToolResolutionError) {
+          throw error;
+        }
+        const err = error as NodeJS.ErrnoException;
+        if (err?.code === "ENOENT") {
+          throw new AIToolResolutionError(
+            "BUNX_NOT_FOUND",
+            "bun command not found while verifying bunx. Install Bun 1.0+ and ensure it is on PATH.",
+            [
+              "Install Bun: https://bun.sh/docs/installation",
+              "After installation, run 'bun --version' to confirm.",
+            ],
+          );
+        }
+        throw new AIToolResolutionError(
+          "BUN_TOO_OLD",
+          `Failed to verify Bun version: ${err?.message ?? "unknown error"}`,
+        );
+      }
+    })();
+  }
+
+  try {
+    await bunxCheckPromise;
+  } catch (error) {
+    bunxCheckPromise = null;
+    throw error;
+  }
+}
+
+export interface ClaudeCommandOptions {
+  mode?: "normal" | "continue" | "resume";
+  skipPermissions?: boolean;
+  extraArgs?: string[];
+}
+
+export function buildClaudeArgs(options: ClaudeCommandOptions = {}): string[] {
+  const args: string[] = [];
+
+  switch (options.mode) {
+    case "continue":
+      args.push("-c");
+      break;
+    case "resume":
+      args.push("-r");
+      break;
+    default:
+      break;
+  }
+
+  if (options.skipPermissions) {
+    args.push(...CLAUDE_PERMISSION_SKIP_ARGS);
+  }
+
+  if (options.extraArgs?.length) {
+    args.push(...options.extraArgs);
+  }
+
+  return args;
+}
+
+export async function resolveClaudeCommand(
+  options: ClaudeCommandOptions = {},
+): Promise<ResolvedCommand> {
+  const args = buildClaudeArgs(options);
+
+  if (await commandExists("claude")) {
+    return {
+      command: "claude",
+      args,
+      usesFallback: false,
+    };
+  }
+
+  await ensureBunxAvailable();
+  return {
+    command: "bunx",
+    args: [CLAUDE_CLI_PACKAGE, ...args],
+    usesFallback: true,
+  };
+}
+
+export interface CodexCommandOptions {
+  mode?: "normal" | "continue" | "resume";
+  bypassApprovals?: boolean;
+  extraArgs?: string[];
+}
+
+export function buildCodexArgs(options: CodexCommandOptions = {}): string[] {
+  const args: string[] = [];
+
+  switch (options.mode) {
+    case "continue":
+      args.push("resume", "--last");
+      break;
+    case "resume":
+      args.push("resume");
+      break;
+    default:
+      break;
+  }
+
+  if (options.bypassApprovals) {
+    args.push("--yolo");
+  }
+
+  if (options.extraArgs?.length) {
+    args.push(...options.extraArgs);
+  }
+
+  args.push(...CODEX_DEFAULT_ARGS);
+  return args;
+}
+
+export async function resolveCodexCommand(
+  options: CodexCommandOptions = {},
+): Promise<ResolvedCommand> {
+  const args = buildCodexArgs(options);
+
+  if (await commandExists("codex")) {
+    return {
+      command: "codex",
+      args,
+      usesFallback: false,
+    };
+  }
+
+  await ensureBunxAvailable();
+  return {
+    command: "bunx",
+    args: [CODEX_CLI_PACKAGE, ...args],
+    usesFallback: true,
+  };
+}
+
+export interface CustomToolCommandOptions extends LaunchOptions {
+  toolId: string;
+}
+
+export async function resolveCustomToolCommand(
+  options: CustomToolCommandOptions,
+): Promise<ResolvedCommand> {
+  const tool = await getToolById(options.toolId);
+  if (!tool) {
+    throw new AIToolResolutionError(
+      "CUSTOM_TOOL_NOT_FOUND",
+      `Custom tool not found: ${options.toolId}`,
+      [
+        "Update ~/.gwt/tools.json to include this ID",
+        "Reload the Web UI after editing the tools list",
+      ],
+    );
+  }
+
+  const execution = await prepareCustomToolExecution(tool, options);
+
+  return {
+    command: execution.command,
+    args: execution.args,
+    usesFallback: tool.type === "bunx",
+    ...(execution.env ? { env: execution.env } : {}),
+  };
+}
+
+export async function isClaudeCodeAvailable(): Promise<boolean> {
+  try {
+    await resolveClaudeCommand();
+    return true;
+  } catch (error) {
+    if (error instanceof AIToolResolutionError) {
+      return false;
+    }
+    return false;
+  }
+}
+
+export async function isCodexAvailable(): Promise<boolean> {
+  try {
+    await resolveCodexCommand();
+    return true;
+  } catch (error) {
+    if (error instanceof AIToolResolutionError) {
+      return false;
+    }
+    return false;
+  }
+}
+
+/**
+ * Test-helper: resets cached bunx availability check.
+ * Not exported in type definitions to avoid production usage.
+ */
+export function __resetBunxCacheForTests(): void {
+  bunxCheckPromise = null;
+}

package/src/services/customToolResolver.ts

@@ -0,0 +1,98 @@
+import { execa } from "execa";
+import type { CustomAITool, LaunchOptions } from "../types/tools.js";
+
+export interface CustomToolExecutionPlan {
+  command: string;
+  args: string[];
+  env?: NodeJS.ProcessEnv;
+}
+
+const WHICH_COMMAND = process.platform === "win32" ? "where" : "which";
+
+export async function resolveCommandPath(commandName: string): Promise<string> {
+  try {
+    const { stdout } = await execa(WHICH_COMMAND, [commandName]);
+    const resolvedPath = (stdout.split("\n")[0] ?? "").trim();
+
+    if (!resolvedPath) {
+      throw new Error(
+        `Command "${commandName}" not found in PATH.\n` +
+          "Please ensure it is installed and available in your PATH.",
+      );
+    }
+
+    return resolvedPath;
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to resolve command "${commandName}".\n${reason}\n` +
+        "Please ensure the command is installed and available in your PATH.",
+    );
+  }
+}
+
+export function buildCustomToolArgs(
+  tool: CustomAITool,
+  options: LaunchOptions = {},
+): string[] {
+  const args: string[] = [];
+
+  if (tool.defaultArgs?.length) {
+    args.push(...tool.defaultArgs);
+  }
+
+  const mode = options.mode ?? "normal";
+  const modeArgs = tool.modeArgs?.[mode];
+  if (modeArgs?.length) {
+    args.push(...modeArgs);
+  }
+
+  if (options.skipPermissions && tool.permissionSkipArgs?.length) {
+    args.push(...tool.permissionSkipArgs);
+  }
+
+  if (options.extraArgs?.length) {
+    args.push(...options.extraArgs);
+  }
+
+  return args;
+}
+
+export async function prepareCustomToolExecution(
+  tool: CustomAITool,
+  options: LaunchOptions = {},
+): Promise<CustomToolExecutionPlan> {
+  const args = buildCustomToolArgs(tool, options);
+  const envOverrides: NodeJS.ProcessEnv | undefined = tool.env
+    ? ({ ...tool.env } as NodeJS.ProcessEnv)
+    : undefined;
+
+  switch (tool.type) {
+    case "path": {
+      return {
+        command: tool.command,
+        args,
+        ...(envOverrides ? { env: envOverrides } : {}),
+      };
+    }
+    case "bunx": {
+      return {
+        command: "bunx",
+        args: [tool.command, ...args],
+        ...(envOverrides ? { env: envOverrides } : {}),
+      };
+    }
+    case "command": {
+      const resolved = await resolveCommandPath(tool.command);
+      return {
+        command: resolved,
+        args,
+        ...(envOverrides ? { env: envOverrides } : {}),
+      };
+    }
+    default: {
+      const exhaustive: never = tool.type;
+      throw new Error(`Unknown custom tool type: ${exhaustive as string}`);
+    }
+  }
+}

package/src/shared/aiToolConstants.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared constants for AI tool integrations.
+ *
+ * These values are consumed by both the CLI (Node) runtime and the Web UI so
+ * that command previews, permission flags, and default arguments stay in sync.
+ */
+
+export const CLAUDE_PERMISSION_SKIP_ARGS = [
+  "--dangerously-skip-permissions",
+] as const;
+
+export const CODEX_DEFAULT_ARGS = [
+  "--enable",
+  "web_search_request",
+  "--model=gpt-5-codex",
+  "--sandbox",
+  "workspace-write",
+  "-c",
+  "model_reasoning_effort=high",
+  "-c",
+  "model_reasoning_summaries=detailed",
+  "-c",
+  "sandbox_workspace_write.network_access=true",
+  "-c",
+  "shell_environment_policy.inherit=all",
+  "-c",
+  "shell_environment_policy.ignore_default_excludes=true",
+  "-c",
+  "shell_environment_policy.experimental_use_profile=true",
+] as const;

package/src/trayicon.d.ts

@@ -0,0 +1,30 @@
+declare module "trayicon" {
+  export interface TrayIconMenuItem {
+    text: string;
+    action?: () => void | Promise<void>;
+    disabled?: boolean;
+    checked?: boolean;
+  }
+
+  export interface TrayIconOptions {
+    icon: Buffer;
+    title?: string;
+    tooltip?: string;
+    action?: () => void | Promise<void>;
+    menu?: TrayIconMenuItem[];
+  }
+
+  export interface TrayIconInstance {
+    setIcon?: (icon: Buffer) => void;
+    setTitle?: (title: string) => void;
+    dispose?: () => void;
+  }
+
+  export function create(options: TrayIconOptions): TrayIconInstance;
+
+  const trayicon: {
+    create: typeof create;
+  };
+
+  export default trayicon;
+}

package/src/types/tools.ts

@@ -69,6 +69,11 @@ export interface CustomAITool {
    */
   icon?: string;
 
+  /**
+   * 説明文（オプション）
+   */
+  description?: string;
+
   /**
    * 実行方式
    *
@@ -118,6 +123,16 @@ export interface CustomAITool {
    * APIキーや設定ファイルパスなどを指定。
    */
   env?: Record<string, string>;
+
+  /**
+   * 作成日時（ISO8601）。tools.jsonのメタデータとして使用。
+   */
+  createdAt?: string;
+
+  /**
+   * 更新日時（ISO8601）。tools.jsonのメタデータとして使用。
+   */
+  updatedAt?: string;
 }
 
 /**

package/src/utils/prompt.ts

@@ -22,7 +22,9 @@ export async function waitForEnter(promptMessage: string): Promise<void> {
 
   if ((stdin as NodeJS.ReadStream & { isRaw?: boolean }).isRaw) {
     try {
-      (stdin as NodeJS.ReadStream & { setRawMode?: (flag: boolean) => void }).setRawMode?.(false);
+      (
+        stdin as NodeJS.ReadStream & { setRawMode?: (flag: boolean) => void }
+      ).setRawMode?.(false);
     } catch {
       // Ignore raw mode errors
     }
@@ -35,17 +37,21 @@ export async function waitForEnter(promptMessage: string): Promise<void> {
       rl.removeAllListeners();
       rl.close();
       const remover = (method: "off" | "removeListener") =>
-        (stdin as unknown as Record<string, (event: string, fn: () => void) => void>)[method]?.(
-          "end",
-          onEnd,
-        );
+        (
+          stdin as unknown as Record<
+            string,
+            (event: string, fn: () => void) => void
+          >
+        )[method]?.("end", onEnd);
       remover("off");
       remover("removeListener");
       const removerErr = (method: "off" | "removeListener") =>
-        (stdin as unknown as Record<string, (event: string, fn: () => void) => void>)[method]?.(
-          "error",
-          onEnd,
-        );
+        (
+          stdin as unknown as Record<
+            string,
+            (event: string, fn: () => void) => void
+          >
+        )[method]?.("error", onEnd);
       removerErr("off");
       removerErr("removeListener");
       if (typeof stdin.pause === "function") {