@akiojin/gwt 2.12.1 → 2.14.0

package/src/web/server/index.ts

@@ -14,23 +14,53 @@ import { PTYManager } from "./pty/manager.js";
 import { WebSocketHandler } from "./websocket/handler.js";
 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 async function startWebServer(): Promise<void> {
-  const fastify = Fastify({
-    logger: {
-      level: process.env.LOG_LEVEL || "info",
-    },
+export interface WebServerHandle {
+  close: () => Promise<void>;
+}
+
+/**
+ * `startWebServer` の起動オプション。
+ */
+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({
+    loggerInstance: serverLogger,
   });
 
   // PTYマネージャーとWebSocketハンドラーを初期化
   const ptyManager = new PTYManager();
-  const wsHandler = new WebSocketHandler(ptyManager);
+  const wsHandler = new WebSocketHandler(ptyManager, fastify.log);
 
   // WebSocketサポートを追加
   await fastify.register(fastifyWebsocket);
@@ -58,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/branches.ts

@@ -4,7 +4,6 @@
  * ブランチ関連のREST APIエンドポイント。
  */
 
-import type { FastifyInstance } from "fastify";
 import {
   listBranches,
   getBranchByName,
@@ -16,12 +15,13 @@ import type {
   BranchSyncRequest,
   BranchSyncResult,
 } from "../../../types/api.js";
+import type { WebFastifyInstance } from "../types.js";
 
 /**
  * ブランチ関連のルートを登録
  */
 export async function registerBranchRoutes(
-  fastify: FastifyInstance,
+  fastify: WebFastifyInstance,
 ): Promise<void> {
   // GET /api/branches - すべてのブランチ一覧を取得
   fastify.get<{ Reply: ApiResponse<Branch[]> }>(

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

@@ -2,7 +2,6 @@
  * Config Routes
  */
 
-import type { FastifyInstance } from "fastify";
 import { loadToolsConfig, saveToolsConfig } from "../../../config/tools.js";
 import {
   loadEnvHistory,
@@ -17,6 +16,7 @@ import type {
 } from "../../../types/api.js";
 import type { CustomAITool as FileCustomAITool } from "../../../types/tools.js";
 import { getImportedEnvKeys } from "../env/importer.js";
+import type { WebFastifyInstance } from "../types.js";
 
 function normalizeEnv(
   env: Record<string, string> | undefined,
@@ -135,7 +135,7 @@ function diffEnvHistory(
 }
 
 export async function registerConfigRoutes(
-  fastify: FastifyInstance,
+  fastify: WebFastifyInstance,
 ): Promise<void> {
   fastify.get<{ Reply: ApiResponse<ConfigPayload> }>(
     "/api/config",

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

@@ -5,19 +5,19 @@
  * 仕様: specs/SPEC-d5e56259/contracts/rest-api.yaml
  */
 
-import type { FastifyInstance } from "fastify";
 import type { PTYManager } from "../pty/manager.js";
 import { registerBranchRoutes } from "./branches.js";
 import { registerWorktreeRoutes } from "./worktrees.js";
 import { registerSessionRoutes } from "./sessions.js";
 import { registerConfigRoutes } from "./config.js";
 import type { HealthResponse } from "../../../types/api.js";
+import type { WebFastifyInstance } from "../types.js";
 
 /**
  * すべてのルートを登録
  */
 export async function registerRoutes(
-  fastify: FastifyInstance,
+  fastify: WebFastifyInstance,
   ptyManager: PTYManager,
 ): Promise<void> {
   // ヘルスチェック

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

@@ -4,8 +4,8 @@
  * AI Toolセッション関連のREST APIエンドポイント。
  */
 
-import type { FastifyInstance } from "fastify";
 import type { PTYManager } from "../pty/manager.js";
+import { AIToolResolutionError } from "../../../services/aiToolResolver.js";
 import type {
   ApiResponse,
   AIToolSession,
@@ -13,12 +13,13 @@ import type {
 } from "../../../types/api.js";
 import { saveSession } from "../../../config/index.js";
 import { execa } from "execa";
+import type { WebFastifyInstance } from "../types.js";
 
 /**
  * セッション関連のルートを登録
  */
 export async function registerSessionRoutes(
-  fastify: FastifyInstance,
+  fastify: WebFastifyInstance,
   ptyManager: PTYManager,
 ): Promise<void> {
   // GET /api/sessions - すべてのセッション一覧を取得
@@ -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

@@ -4,7 +4,6 @@
  * Worktree関連のREST APIエンドポイント。
  */
 
-import type { FastifyInstance } from "fastify";
 import {
   listWorktrees,
   getWorktreeByPath,
@@ -16,12 +15,13 @@ import type {
   Worktree,
   CreateWorktreeRequest,
 } from "../../../types/api.js";
+import type { WebFastifyInstance } from "../types.js";
 
 /**
  * Worktree関連のルートを登録
  */
 export async function registerWorktreeRoutes(
-  fastify: FastifyInstance,
+  fastify: WebFastifyInstance,
 ): Promise<void> {
   // GET /api/worktrees - すべてのWorktree一覧を取得
   fastify.get<{ Reply: ApiResponse<Worktree[]> }>(
@@ -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,