@akiojin/gwt 2.13.0 → 3.0.0

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") {

package/src/utils/session.ts

@@ -11,7 +11,9 @@ const UUID_REGEX =
  * @returns true if the string is a valid UUID format
  */
 export function isValidUuidSessionId(id: string): boolean {
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    id,
+  );
 }
 
 function pickSessionIdFromObject(obj: unknown): string | null {
@@ -34,7 +36,13 @@ function pickSessionIdFromObject(obj: unknown): string | null {
 function pickCwdFromObject(obj: unknown): string | null {
   if (!obj || typeof obj !== "object") return null;
   const candidate = obj as Record<string, unknown>;
-  const keys = ["cwd", "workingDirectory", "workdir", "directory", "projectPath"];
+  const keys = [
+    "cwd",
+    "workingDirectory",
+    "workdir",
+    "directory",
+    "projectPath",
+  ];
   for (const key of keys) {
     const value = candidate[key];
     if (typeof value === "string" && value.trim().length > 0) {
@@ -118,7 +126,12 @@ async function findLatestFile(
 async function findNewestSessionIdFromDir(
   dir: string,
   recursive: boolean,
-  options: { since?: number; until?: number; preferClosestTo?: number; windowMs?: number } = {},
+  options: {
+    since?: number;
+    until?: number;
+    preferClosestTo?: number;
+    windowMs?: number;
+  } = {},
 ): Promise<{ id: string; mtime: number } | null> {
   try {
     const files: { fullPath: string; mtime: number }[] = [];
@@ -423,7 +436,12 @@ function generateClaudeProjectPathCandidates(cwd: string): string[] {
 
 export async function findLatestClaudeSessionId(
   cwd: string,
-  options: { since?: number; until?: number; preferClosestTo?: number; windowMs?: number } = {},
+  options: {
+    since?: number;
+    until?: number;
+    preferClosestTo?: number;
+    windowMs?: number;
+  } = {},
 ): Promise<string | null> {
   const found = await findLatestClaudeSession(cwd, options);
   return found?.id ?? null;
@@ -436,7 +454,12 @@ export interface ClaudeSessionInfo {
 
 export async function findLatestClaudeSession(
   cwd: string,
-  options: { since?: number; until?: number; preferClosestTo?: number; windowMs?: number } = {},
+  options: {
+    since?: number;
+    until?: number;
+    preferClosestTo?: number;
+    windowMs?: number;
+  } = {},
 ): Promise<ClaudeSessionInfo | null> {
   const rootCandidates: string[] = [];
   if (process.env.CLAUDE_CONFIG_DIR) {
@@ -481,9 +504,15 @@ export async function findLatestClaudeSession(
       try {
         const line = lines[i] ?? "";
         const parsed = JSON.parse(line) as Record<string, unknown>;
-        const project = typeof parsed.project === "string" ? parsed.project : null;
-        const sessionId = typeof parsed.sessionId === "string" ? parsed.sessionId : null;
-        if (project && sessionId && (project === cwd || cwd.startsWith(project))) {
+        const project =
+          typeof parsed.project === "string" ? parsed.project : null;
+        const sessionId =
+          typeof parsed.sessionId === "string" ? parsed.sessionId : null;
+        if (
+          project &&
+          sessionId &&
+          (project === cwd || cwd.startsWith(project))
+        ) {
           return { id: sessionId, mtime: Date.now() };
         }
       } catch {
@@ -513,10 +542,16 @@ export async function waitForClaudeSessionId(
   const deadline = Date.now() + timeoutMs;
 
   while (Date.now() < deadline) {
-    const opt: { since?: number; until?: number; preferClosestTo?: number; windowMs?: number } = {};
+    const opt: {
+      since?: number;
+      until?: number;
+      preferClosestTo?: number;
+      windowMs?: number;
+    } = {};
     if (options.since !== undefined) opt.since = options.since;
     if (options.until !== undefined) opt.until = options.until;
-    if (options.preferClosestTo !== undefined) opt.preferClosestTo = options.preferClosestTo;
+    if (options.preferClosestTo !== undefined)
+      opt.preferClosestTo = options.preferClosestTo;
     if (options.windowMs !== undefined) opt.windowMs = options.windowMs;
 
     const found = await findLatestClaudeSession(cwd, opt);
@@ -560,7 +595,13 @@ async function findLatestNestedSessionFile(
 
 export async function findLatestGeminiSession(
   _cwd: string,
-  options: { since?: number; until?: number; preferClosestTo?: number; windowMs?: number; cwd?: string | null } = {},
+  options: {
+    since?: number;
+    until?: number;
+    preferClosestTo?: number;
+    windowMs?: number;
+    cwd?: string | null;
+  } = {},
 ): Promise<GeminiSessionInfo | null> {
   // Gemini stores sessions/logs under ~/.gemini/tmp/<project_hash>/(chats|logs).json
   const baseDir = path.join(homedir(), ".gemini", "tmp");
@@ -588,17 +629,15 @@ export async function findLatestGeminiSession(
 
   const ref = options.preferClosestTo;
   const window = options.windowMs ?? 30 * 60 * 1000;
-  pool = pool
-    .slice()
-    .sort((a, b) => {
-      if (typeof ref === "number") {
-        const da = Math.abs(a.mtime - ref);
-        const db = Math.abs(b.mtime - ref);
-        if (da === db) return b.mtime - a.mtime;
-        if (da <= window || db <= window) return da - db;
-      }
-      return b.mtime - a.mtime;
-    });
+  pool = pool.slice().sort((a, b) => {
+    if (typeof ref === "number") {
+      const da = Math.abs(a.mtime - ref);
+      const db = Math.abs(b.mtime - ref);
+      if (da === db) return b.mtime - a.mtime;
+      if (da <= window || db <= window) return da - db;
+    }
+    return b.mtime - a.mtime;
+  });
 
   for (const file of pool) {
     const info = await readSessionInfoFromFile(file.fullPath);
@@ -620,16 +659,31 @@ export async function findLatestGeminiSession(
 
 export async function findLatestGeminiSessionId(
   cwd: string,
-  options: { since?: number; until?: number; preferClosestTo?: number; windowMs?: number; cwd?: string | null } = {},
+  options: {
+    since?: number;
+    until?: number;
+    preferClosestTo?: number;
+    windowMs?: number;
+    cwd?: string | null;
+  } = {},
 ): Promise<string | null> {
-  const normalized: { since?: number; until?: number; preferClosestTo?: number; windowMs?: number } = {};
+  const normalized: {
+    since?: number;
+    until?: number;
+    preferClosestTo?: number;
+    windowMs?: number;
+  } = {};
   if (options.since !== undefined) normalized.since = options.since as number;
   if (options.until !== undefined) normalized.until = options.until as number;
   if (options.preferClosestTo !== undefined)
     normalized.preferClosestTo = options.preferClosestTo as number;
-  if (options.windowMs !== undefined) normalized.windowMs = options.windowMs as number;
+  if (options.windowMs !== undefined)
+    normalized.windowMs = options.windowMs as number;
 
-  const found = await findLatestGeminiSession(cwd, { ...normalized, cwd: options.cwd ?? cwd });
+  const found = await findLatestGeminiSession(cwd, {
+    ...normalized,
+    cwd: options.cwd ?? cwd,
+  });
   return found?.id ?? null;
 }