@akiojin/gwt 2.13.0 → 3.0.0

package/src/web/server/index.ts

@@ -16,14 +16,42 @@ import { registerRoutes } from "./routes/index.js";
 import { importOsEnvIntoSharedConfig } from "./env/importer.js";
 import { createLogger } from "../../logging/logger.js";
 import type { WebFastifyInstance } from "./types.js";
+import { disposeSystemTray, startSystemTray } from "./tray.js";
+import { resolveWebUiPort } from "../../utils/webui.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 /**
- * Webサーバーを起動
+ * Web UI サーバーのライフサイクル操作ハンドル。
+ *
+ * `close()` は Web UI サーバーを停止し、関連リソース（PTY/トレイ等）を解放します。
+ */
+export interface WebServerHandle {
+  close: () => Promise<void>;
+}
+
+/**
+ * `startWebServer` の起動オプション。
  */
-export async function startWebServer(): Promise<void> {
+export interface StartWebServerOptions {
+  /**
+   * true の場合、Web UI サーバーが CLI 本体の終了をブロックしないようにします。
+   * （内部で `server.unref()` を呼び、サーバーの存在がプロセス生存を維持しないようにします）
+   */
+  background?: boolean;
+}
+
+/**
+ * Web UI サーバーを起動します。
+ *
+ * @param options - 起動オプション
+ * @returns Web UI サーバー停止用のハンドル
+ * @throws サーバー起動（listen/初期化）に失敗した場合
+ */
+export async function startWebServer(
+  options: StartWebServerOptions = {},
+): Promise<WebServerHandle> {
   const serverLogger = createLogger({ category: "server" });
 
   const fastify: WebFastifyInstance = Fastify({
@@ -32,7 +60,7 @@ export async function startWebServer(): Promise<void> {
 
   // PTYマネージャーとWebSocketハンドラーを初期化
   const ptyManager = new PTYManager();
-  const wsHandler = new WebSocketHandler(ptyManager);
+  const wsHandler = new WebSocketHandler(ptyManager, fastify.log);
 
   // WebSocketサポートを追加
   await fastify.register(fastifyWebsocket);
@@ -60,17 +88,46 @@ export async function startWebServer(): Promise<void> {
   });
 
   // サーバー起動
-  try {
-    const port = process.env.PORT ? parseInt(process.env.PORT, 10) : 3000;
-    // Docker環境からホストOSでアクセスできるよう、0.0.0.0でリッスン
-    // IPv4/IPv6両方対応のため、listenOnStart: false も検討可能
-    const host = process.env.HOST || "0.0.0.0";
-
-    await fastify.listen({ port, host });
-    console.log(`Web UI server running at http://${host}:${port}`);
-    console.log(`Access from host: http://localhost:${port}`);
-  } catch (err) {
-    fastify.log.error(err);
-    process.exit(1);
+  const port = resolveWebUiPort();
+  // Docker環境からホストOSでアクセスできるよう、0.0.0.0でリッスン
+  // IPv4/IPv6両方対応のため、listenOnStart: false も検討可能
+  const host = process.env.HOST || "0.0.0.0";
+
+  await fastify.listen({ port, host });
+  const accessUrl = `http://localhost:${port}`;
+  serverLogger.info({ host, port, accessUrl }, "Web UI server started");
+  await startSystemTray(accessUrl);
+
+  if (options.background) {
+    fastify.server?.unref?.();
   }
+
+  let closed = false;
+  return {
+    close: async () => {
+      if (closed) return;
+      closed = true;
+
+      try {
+        try {
+          disposeSystemTray();
+        } catch (err) {
+          serverLogger.warn({ err }, "System tray cleanup failed");
+        }
+
+        for (const session of ptyManager.list()) {
+          try {
+            ptyManager.delete(session.sessionId);
+          } catch (err) {
+            serverLogger.warn(
+              { err, sessionId: session.sessionId },
+              "Failed to delete PTY session",
+            );
+          }
+        }
+      } finally {
+        await fastify.close();
+      }
+    },
+  };
 }

package/src/web/server/pty/manager.ts

@@ -9,6 +9,14 @@ import * as pty from "node-pty";
 import type { IPty } from "node-pty";
 import { randomUUID } from "node:crypto";
 import type { AIToolSession } from "../../../types/api.js";
+import {
+  resolveClaudeCommand,
+  resolveCodexCommand,
+  resolveCustomToolCommand,
+  AIToolResolutionError,
+  type ResolvedCommand,
+} from "../../../services/aiToolResolver.js";
+import { loadToolsConfig } from "../../../config/tools.js";
 
 export interface PTYInstance {
   ptyProcess: IPty;
@@ -24,37 +32,80 @@ export class PTYManager {
   /**
    * 新しいPTYセッションを作成
    */
-  public spawn(
+  public async spawn(
     toolType: "claude-code" | "codex-cli" | "custom",
     worktreePath: string,
     mode: "normal" | "continue" | "resume",
-    toolName?: string | null,
-    cols = 80,
-    rows = 24,
-  ): { sessionId: string; session: AIToolSession } {
+    options: {
+      toolName?: string | null;
+      cols?: number;
+      rows?: number;
+      skipPermissions?: boolean;
+      bypassApprovals?: boolean;
+      extraArgs?: string[];
+      customToolId?: string | null;
+    } = {},
+  ): Promise<{ sessionId: string; session: AIToolSession }> {
+    const cols = options.cols ?? 80;
+    const rows = options.rows ?? 24;
+    const toolName = options.toolName ?? null;
     const sessionId = randomUUID();
 
-    // AI Toolコマンドを構築
-    const command = this.buildCommand(toolType, mode, toolName);
-    const args = this.buildArgs(toolType, mode);
+    const resolverOptions: {
+      toolName?: string | null;
+      skipPermissions?: boolean;
+      bypassApprovals?: boolean;
+      extraArgs?: string[];
+      customToolId?: string | null;
+    } = {};
+
+    if (toolName !== null) {
+      resolverOptions.toolName = toolName;
+    }
+    if (options.skipPermissions !== undefined) {
+      resolverOptions.skipPermissions = options.skipPermissions;
+    }
+    if (options.bypassApprovals !== undefined) {
+      resolverOptions.bypassApprovals = options.bypassApprovals;
+    }
+    if (options.extraArgs && options.extraArgs.length > 0) {
+      resolverOptions.extraArgs = options.extraArgs;
+    }
+    if (options.customToolId !== undefined) {
+      resolverOptions.customToolId = options.customToolId;
+    }
+
+    const resolved = await this.resolveCommand(toolType, mode, resolverOptions);
+    const sharedEnv = await this.loadSharedEnv();
+
+    const env: NodeJS.ProcessEnv = {
+      ...process.env,
+      ...sharedEnv,
+      TERM: "xterm-256color",
+      COLORTERM: "truecolor",
+    };
+
+    if (resolved.env) {
+      Object.assign(env, resolved.env);
+    }
+
+    if (toolType === "claude-code" && options.skipPermissions && isRootUser()) {
+      env.IS_SANDBOX = "1";
+    }
 
     // PTYプロセスをスポーン
-    const ptyProcess = pty.spawn(command, args, {
+    const ptyProcess = pty.spawn(resolved.command, resolved.args, {
       name: "xterm-256color",
       cols,
       rows,
       cwd: worktreePath,
-      env: {
-        ...process.env,
-        TERM: "xterm-256color",
-        COLORTERM: "truecolor",
-      },
+      env,
     });
 
     const session: AIToolSession = {
       sessionId,
       toolType,
-      toolName: toolName || null,
+      toolName: options.customToolId ?? toolName ?? null,
       mode,
       worktreePath,
       ptyPid: ptyProcess.pid,
@@ -133,57 +184,79 @@ export class PTYManager {
     return Array.from(this.instances.values()).map((inst) => inst.session);
   }
 
-  /**
-   * AI Toolのコマンドを構築
-   */
-  private buildCommand(
+  private async resolveCommand(
     toolType: "claude-code" | "codex-cli" | "custom",
     mode: "normal" | "continue" | "resume",
-    toolName?: string | null,
-  ): string {
-    if (toolType === "custom" && toolName) {
-      // カスタムツールは別途config.jsonから取得する必要があるが、
-      // ここでは簡易実装としてtoolNameをそのままコマンドとして使用
-      return toolName;
-    }
-
-    if (toolType === "codex-cli") {
-      return "codex";
-    }
-
-    // claude-code
-    return "claude";
-  }
-
-  /**
-   * AI Toolの引数を構築
-   */
-  private buildArgs(
-    toolType: "claude-code" | "codex-cli" | "custom",
-    mode: "normal" | "continue" | "resume",
-  ): string[] {
+    options: {
+      toolName?: string | null;
+      skipPermissions?: boolean;
+      bypassApprovals?: boolean;
+      extraArgs?: string[];
+      customToolId?: string | null;
+    },
+  ): Promise<ResolvedCommand> {
     if (toolType === "custom") {
-      // カスタムツールの引数は別途config.jsonから取得
-      return [];
+      const toolId = options.customToolId ?? options.toolName;
+      if (!toolId) {
+        throw new AIToolResolutionError(
+          "COMMAND_NOT_FOUND",
+          "Custom tool identifier is required to start a session.",
+        );
+      }
+
+      return resolveCustomToolCommand({
+        toolId,
+        mode,
+        ...(options.skipPermissions !== undefined
+          ? { skipPermissions: options.skipPermissions }
+          : {}),
+        ...(options.extraArgs ? { extraArgs: options.extraArgs } : {}),
+      });
     }
 
     if (toolType === "codex-cli") {
-      if (mode === "continue") {
-        return ["--continue"];
+      const codexOptions: {
+        mode: "normal" | "continue" | "resume";
+        bypassApprovals?: boolean;
+        extraArgs?: string[];
+      } = { mode };
+
+      if (options.bypassApprovals !== undefined) {
+        codexOptions.bypassApprovals = options.bypassApprovals;
       }
-      if (mode === "resume") {
-        return ["--resume"];
+      if (options.extraArgs && options.extraArgs.length > 0) {
+        codexOptions.extraArgs = options.extraArgs;
       }
-      return [];
+
+      return resolveCodexCommand(codexOptions);
     }
 
-    // claude-code
-    if (mode === "continue") {
-      return ["--continue"];
+    const claudeOptions: {
+      mode: "normal" | "continue" | "resume";
+      skipPermissions?: boolean;
+      extraArgs?: string[];
+    } = { mode };
+
+    if (options.skipPermissions !== undefined) {
+      claudeOptions.skipPermissions = options.skipPermissions;
     }
-    if (mode === "resume") {
-      return ["--resume"];
+    if (options.extraArgs && options.extraArgs.length > 0) {
+      claudeOptions.extraArgs = options.extraArgs;
     }
-    return [];
+
+    return resolveClaudeCommand(claudeOptions);
+  }
+
+  private async loadSharedEnv(): Promise<Record<string, string>> {
+    const config = await loadToolsConfig();
+    return { ...(config.env ?? {}) };
+  }
+}
+
+function isRootUser(): boolean {
+  try {
+    return typeof process.getuid === "function" && process.getuid() === 0;
+  } catch {
+    return false;
   }
 }

package/src/web/server/routes/sessions.ts

@@ -5,6 +5,7 @@
  */
 
 import type { PTYManager } from "../pty/manager.js";
+import { AIToolResolutionError } from "../../../services/aiToolResolver.js";
 import type {
   ApiResponse,
   AIToolSession,
@@ -28,7 +29,7 @@ export async function registerSessionRoutes(
       try {
         const sessions = ptyManager.list();
         return { success: true, data: sessions };
-      } catch (error) {
+      } catch (error: unknown) {
         const errorMsg = error instanceof Error ? error.message : String(error);
         reply.code(500);
         return {
@@ -46,13 +47,55 @@ export async function registerSessionRoutes(
     Reply: ApiResponse<AIToolSession>;
   }>("/api/sessions", async (request, reply) => {
     try {
-      const { toolType, toolName, mode, worktreePath } = request.body;
+      const {
+        toolType,
+        toolName,
+        mode,
+        worktreePath,
+        skipPermissions,
+        bypassApprovals,
+        extraArgs,
+        customToolId,
+      } = request.body;
+
+      const spawnOptions: {
+        toolName?: string | null;
+        skipPermissions?: boolean;
+        bypassApprovals?: boolean;
+        extraArgs?: string[];
+        customToolId?: string | null;
+      } = {};
+
+      if (typeof toolName !== "undefined") {
+        spawnOptions.toolName = toolName;
+      }
+      if (typeof skipPermissions !== "undefined") {
+        spawnOptions.skipPermissions = skipPermissions;
+      }
+      if (typeof bypassApprovals !== "undefined") {
+        spawnOptions.bypassApprovals = bypassApprovals;
+      }
+      if (Array.isArray(extraArgs) && extraArgs.length > 0) {
+        spawnOptions.extraArgs = extraArgs;
+      }
+      if (typeof customToolId !== "undefined") {
+        spawnOptions.customToolId = customToolId;
+      }
 
-      const { session } = ptyManager.spawn(
+      if (toolType === "custom" && !toolName && !customToolId) {
+        reply.code(400);
+        return {
+          success: false,
+          error: "Custom tool requires toolName or customToolId",
+          details: null,
+        };
+      }
+
+      const { session } = await ptyManager.spawn(
         toolType,
         worktreePath,
         mode,
-        toolName,
+        spawnOptions,
       );
 
       // 履歴を永続化（best-effort）
@@ -95,7 +138,16 @@ export async function registerSessionRoutes(
 
       reply.code(201);
       return { success: true, data: session };
-    } catch (error) {
+    } catch (error: unknown) {
+      if (error instanceof AIToolResolutionError) {
+        reply.code(400);
+        return {
+          success: false,
+          error: error.message,
+          details: error.hints?.join("\n") ?? null,
+        };
+      }
+
       const errorMsg = error instanceof Error ? error.message : String(error);
       reply.code(500);
       return {
@@ -125,7 +177,7 @@ export async function registerSessionRoutes(
       }
 
       return { success: true, data: instance.session };
-    } catch (error) {
+    } catch (error: unknown) {
       const errorMsg = error instanceof Error ? error.message : String(error);
       reply.code(500);
       return {
@@ -157,7 +209,7 @@ export async function registerSessionRoutes(
       }
 
       return { success: true };
-    } catch (error) {
+    } catch (error: unknown) {
       const errorMsg = error instanceof Error ? error.message : String(error);
       reply.code(500);
       return {

package/src/web/server/routes/worktrees.ts

@@ -64,13 +64,13 @@ export async function registerWorktreeRoutes(
     }
   });
 
-  // DELETE /api/worktrees - Worktreeを削除
+  // DELETE /api/worktrees/delete - Worktreeを削除
   fastify.delete<{
-    Querystring: { path: string };
+    Querystring: { path: string; force?: boolean };
     Reply:
       | { success: true }
       | { success: false; error: string; details?: string | null };
-  }>("/api/worktrees", async (request, reply) => {
+  }>("/api/worktrees/delete", async (request, reply) => {
     try {
       const { path } = request.query;
 

package/src/web/server/services/worktrees.ts

@@ -30,6 +30,8 @@ export async function listWorktrees(): Promise<Worktree[]> {
     isProtected: isProtectedBranchName(wt.branch),
     createdAt: null, // git worktreeからは取得不可
     lastAccessedAt: null, // git worktreeからは取得不可
+    divergence: null,
+    prInfo: null,
   }));
 }
 
@@ -50,16 +52,22 @@ export async function createNewWorktree(
   branchName: string,
   createBranch: boolean,
 ): Promise<Worktree> {
-  const { getRepositoryRoot, getCurrentBranch } = await import(
-    "../../../git.js"
-  );
+  // 保護ブランチのチェック
+  if (isProtectedBranchName(branchName)) {
+    throw new Error(
+      `Cannot create worktree for protected branch: ${branchName}. Protected branches (main, develop, master) must remain in the main repository.`,
+    );
+  }
+
+  const { getRepositoryRoot, getCurrentBranch } =
+    await import("../../../git.js");
 
   const [repoRoot, currentBranch] = await Promise.all([
     getRepositoryRoot(),
     getCurrentBranch(),
   ]);
 
-  const worktreePath = await generateWorktreePath(branchName, repoRoot);
+  const worktreePath = await generateWorktreePath(repoRoot, branchName);
 
   await createWorktreeCore({
     branchName,

package/src/web/server/tray.ts

@@ -0,0 +1,120 @@
+import { execa } from "execa";
+import { createLogger } from "../../logging/logger.js";
+
+/**
+ * URL を開く関数の型定義
+ * @param url - 開くURL
+ */
+export type OpenUrlFn = (url: string) => Promise<void> | void;
+
+const TRAY_ICON_BASE64 =
+  "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQBAMAAADt3eJSAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAJ1BMVEUAAAAAvNQAvNQAvNQAvNQAvNQAvNQAvNQAvNQAvNQAvNQAvNT////J1ubyAAAAC3RSTlMAJYTcgyQJnJ3U3WXfUogAAAABYktHRAyBs1FjAAAAB3RJTUUH6QwMCRccbOpRBQAAAFdJREFUCNdjYEAARuXNriCarXr37t1tQEYmkN69M4GBoRvE2F3AwAqmd29kYIEwNjEwQxibGbghjN0MXDARJpgaqK6tDAzVUHMQJoPtKgPZyuq8S5WBAQBeRj51tvdhawAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAyNS0xMi0xMlQwOToyMzoyOCswMDowMBPEA5UAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMjUtMTItMTJUMDk6MjM6MjgrMDA6MDBimbspAAAAAElFTkSuQmCC";
+
+let trayInitAttempted = false;
+type TrayHandle = { dispose?: () => void; kill?: () => void };
+let trayInstance: TrayHandle | null = null;
+let trayInitPromise: Promise<TrayHandle> | null = null;
+
+function shouldEnableTray(
+  platform: NodeJS.Platform = process.platform,
+): boolean {
+  // NOTE: `trayicon` is a win32-only dependency.
+  if (platform !== "win32") return false;
+  if (process.env.GWT_DISABLE_TRAY?.toLowerCase() === "true") return false;
+  if (process.env.GWT_DISABLE_TRAY === "1") return false;
+  if (process.env.CI) return false;
+  return true;
+}
+
+/**
+ * デフォルトブラウザでURLを開く
+ * @param url - 開くURL
+ */
+export async function openUrl(url: string): Promise<void> {
+  const platform = process.platform;
+  try {
+    if (platform === "win32") {
+      await execa("explorer.exe", [url], { windowsHide: true });
+      return;
+    }
+    if (platform === "darwin") {
+      await execa("open", [url]);
+      return;
+    }
+    await execa("xdg-open", [url], { stdio: "ignore" });
+  } catch {
+    // Ignore errors to avoid disrupting CLI/Web UI
+  }
+}
+
+/**
+ * システムトレイアイコンを初期化
+ * @param url - Web UI のURL（ダブルクリック時に開く）
+ * @param opts - オプション設定
+ * @param opts.openUrl - URL を開くカスタム関数（テスト用）
+ */
+export async function startSystemTray(
+  url: string,
+  opts?: { openUrl?: OpenUrlFn; platform?: NodeJS.Platform },
+): Promise<void> {
+  if (trayInitAttempted || !shouldEnableTray(opts?.platform)) return;
+  trayInitAttempted = true;
+
+  const logger = createLogger({ category: "tray" });
+
+  try {
+    const mod = (await import("trayicon")) as Record<string, unknown> & {
+      default?: Record<string, unknown>;
+    };
+    const create = mod.create ?? mod.default?.create;
+    if (typeof create !== "function") {
+      throw new Error("trayicon.create not available");
+    }
+
+    const icon = Buffer.from(TRAY_ICON_BASE64, "base64");
+    const open = opts?.openUrl ?? openUrl;
+
+    const initPromise = Promise.resolve(
+      create({
+        icon,
+        title: "gwt Web UI",
+        tooltip: "Double-click to open Web UI",
+        action: async () => {
+          await open(url);
+        },
+      }) as TrayHandle,
+    );
+    trayInitPromise = initPromise;
+
+    void initPromise
+      .then((tray) => {
+        if (trayInitPromise !== initPromise) {
+          tray.dispose?.();
+          tray.kill?.();
+          return;
+        }
+        trayInstance = tray;
+      })
+      .catch((err) => {
+        if (trayInitPromise !== initPromise) return;
+        logger.warn({ err }, "System tray failed to initialize");
+      });
+  } catch (err) {
+    logger.warn({ err }, "System tray failed to initialize");
+  }
+}
+
+/**
+ * システムトレイアイコンを破棄
+ */
+export function disposeSystemTray(): void {
+  trayInitPromise = null;
+
+  const instance = trayInstance;
+  trayInstance = null;
+
+  instance?.dispose?.();
+  instance?.kill?.();
+
+  trayInitAttempted = false;
+}