@akiojin/gwt 4.10.0 → 4.11.6

package/src/web/client/src/lib/coding-agent-colors.ts

@@ -0,0 +1,149 @@
+/**
+ * Coding Agent Color Definitions for Web UI
+ *
+ * This module provides consistent color definitions for coding agents
+ * in the Web UI (React/Tailwind) (SPEC-3b0ed29b FR-024~FR-027).
+ *
+ * Note: This mirrors the CLI color utility at src/utils/coding-agent-colors.ts
+ * Both files should be kept in sync.
+ */
+
+/**
+ * Tool ID constants for coding agents
+ */
+export const CODING_AGENT_TOOL_IDS = {
+  CLAUDE_CODE: "claude-code",
+  CODEX_CLI: "codex-cli",
+  GEMINI_CLI: "gemini-cli",
+  OPENCODE: "opencode",
+} as const;
+
+/**
+ * Color definitions for coding agents
+ */
+export const CODING_AGENT_COLORS = {
+  [CODING_AGENT_TOOL_IDS.CLAUDE_CODE]: {
+    hex: "#f6e05e",
+    tailwind: "text-yellow-400",
+    bgTailwind: "bg-yellow-400/20",
+    borderTailwind: "border-yellow-400",
+  },
+  [CODING_AGENT_TOOL_IDS.CODEX_CLI]: {
+    hex: "#4fd1c5",
+    tailwind: "text-cyan-400",
+    bgTailwind: "bg-cyan-400/20",
+    borderTailwind: "border-cyan-400",
+  },
+  [CODING_AGENT_TOOL_IDS.GEMINI_CLI]: {
+    hex: "#d53f8c",
+    tailwind: "text-pink-500",
+    bgTailwind: "bg-pink-500/20",
+    borderTailwind: "border-pink-500",
+  },
+  [CODING_AGENT_TOOL_IDS.OPENCODE]: {
+    hex: "#48bb78",
+    tailwind: "text-green-400",
+    bgTailwind: "bg-green-400/20",
+    borderTailwind: "border-green-400",
+  },
+} as const;
+
+/**
+ * Default color for unknown/custom agents
+ */
+export const DEFAULT_AGENT_COLOR = {
+  hex: "#a0aec0",
+  tailwind: "text-gray-400",
+  bgTailwind: "bg-gray-400/20",
+  borderTailwind: "border-gray-400",
+};
+
+/**
+ * Get Tailwind CSS text color class for a coding agent
+ *
+ * @param toolId - The tool ID (e.g., "claude-code", "codex-cli")
+ * @returns Tailwind CSS class name
+ */
+export function getAgentTailwindClass(toolId?: string | null): string {
+  if (!toolId) {
+    return DEFAULT_AGENT_COLOR.tailwind;
+  }
+
+  const color = CODING_AGENT_COLORS[toolId as keyof typeof CODING_AGENT_COLORS];
+  return color?.tailwind ?? DEFAULT_AGENT_COLOR.tailwind;
+}
+
+/**
+ * Get Tailwind CSS background color class for a coding agent
+ *
+ * @param toolId - The tool ID (e.g., "claude-code", "codex-cli")
+ * @returns Tailwind CSS class name for background
+ */
+export function getAgentBgTailwindClass(toolId?: string | null): string {
+  if (!toolId) {
+    return DEFAULT_AGENT_COLOR.bgTailwind;
+  }
+
+  const color = CODING_AGENT_COLORS[toolId as keyof typeof CODING_AGENT_COLORS];
+  return color?.bgTailwind ?? DEFAULT_AGENT_COLOR.bgTailwind;
+}
+
+/**
+ * Get hex color for a coding agent
+ *
+ * @param toolId - The tool ID (e.g., "claude-code", "codex-cli")
+ * @returns Hex color string
+ */
+export function getAgentHexColor(toolId?: string | null): string {
+  if (!toolId) {
+    return DEFAULT_AGENT_COLOR.hex;
+  }
+
+  const color = CODING_AGENT_COLORS[toolId as keyof typeof CODING_AGENT_COLORS];
+  return color?.hex ?? DEFAULT_AGENT_COLOR.hex;
+}
+
+/**
+ * Normalize agent type string to tool ID
+ * Handles various naming conventions used across the codebase
+ *
+ * @param agentType - Agent type string (e.g., "claude", "codex-cli", "Claude Code")
+ * @returns Normalized tool ID
+ */
+export function normalizeAgentToToolId(
+  agentType?: string | null,
+): string | null {
+  if (!agentType) return null;
+
+  const normalized = agentType.toLowerCase().trim();
+
+  // Direct matches
+  if (normalized === "claude-code" || normalized === "claude") {
+    return CODING_AGENT_TOOL_IDS.CLAUDE_CODE;
+  }
+  if (normalized === "codex-cli" || normalized === "codex") {
+    return CODING_AGENT_TOOL_IDS.CODEX_CLI;
+  }
+  if (normalized === "gemini-cli" || normalized === "gemini") {
+    return CODING_AGENT_TOOL_IDS.GEMINI_CLI;
+  }
+  if (normalized === "opencode" || normalized === "open-code") {
+    return CODING_AGENT_TOOL_IDS.OPENCODE;
+  }
+
+  // Label-based matches
+  if (normalized.includes("claude")) {
+    return CODING_AGENT_TOOL_IDS.CLAUDE_CODE;
+  }
+  if (normalized.includes("codex")) {
+    return CODING_AGENT_TOOL_IDS.CODEX_CLI;
+  }
+  if (normalized.includes("gemini")) {
+    return CODING_AGENT_TOOL_IDS.GEMINI_CLI;
+  }
+  if (normalized.includes("opencode")) {
+    return CODING_AGENT_TOOL_IDS.OPENCODE;
+  }
+
+  return agentType; // Return as-is for custom agents
+}

package/src/web/client/src/pages/BranchDetailPage.tsx

@@ -210,7 +210,7 @@ export function BranchDetailPage() {
   // Computed values
   const canStartSession = Boolean(branch.worktreePath);
   const divergenceInfo = branch.divergence ?? null;
-  const hasBlockingDivergence = Boolean(
+  const hasConflictingDivergence = Boolean(
     divergenceInfo && divergenceInfo.ahead > 0 && divergenceInfo.behind > 0,
   );
   const needsRemoteSync = Boolean(
@@ -218,7 +218,7 @@ export function BranchDetailPage() {
     divergenceInfo &&
     divergenceInfo.behind > 0 &&
     divergenceInfo.ahead === 0 &&
-    !hasBlockingDivergence,
+    !hasConflictingDivergence,
   );
   const isSyncingBranch = syncBranch.isPending;
 
@@ -270,14 +270,6 @@ export function BranchDetailPage() {
       return;
     }
 
-    if (hasBlockingDivergence) {
-      setBanner({
-        type: "error",
-        message: "差分を解消してから起動してください。",
-      });
-      return;
-    }
-
     if (
       skipPermissions &&
       !window.confirm("権限チェックをスキップして起動します。続行しますか？")
@@ -293,6 +285,13 @@ export function BranchDetailPage() {
           : selectedTool.target === "custom"
             ? "custom"
             : "claude-code";
+      const resumeSessionId =
+        selectedMode === "normal"
+          ? null
+          : latestToolUsage?.sessionId &&
+              latestToolUsage.toolId === selectedToolId
+            ? latestToolUsage.sessionId
+            : null;
       const extraArgs = extraArgsText
         .split(/\s+/)
         .map((c) => c.trim())
@@ -309,6 +308,7 @@ export function BranchDetailPage() {
         ...(selectedTool.target === "codex"
           ? { bypassApprovals: skipPermissions }
           : {}),
+        ...(resumeSessionId ? { resumeSessionId } : {}),
         ...(extraArgs.length ? { extraArgs } : {}),
       } as const;
 
@@ -478,7 +478,7 @@ export function BranchDetailPage() {
               isStartingSession={isStartingSession}
               isSyncingBranch={isSyncingBranch}
               needsRemoteSync={needsRemoteSync}
-              hasBlockingDivergence={hasBlockingDivergence}
+              hasConflictingDivergence={hasConflictingDivergence}
               onToolChange={setSelectedToolId}
               onModeChange={setSelectedMode}
               onSkipPermissionsChange={setSkipPermissions}

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

@@ -8,6 +8,7 @@
 import * as pty from "node-pty";
 import type { IPty } from "node-pty";
 import { randomUUID } from "node:crypto";
+import { execa } from "execa";
 import type { CodingAgentSession } from "../../../types/api.js";
 import {
   resolveClaudeCommand,
@@ -17,6 +18,11 @@ import {
   type ResolvedCommand,
 } from "../../../services/codingAgentResolver.js";
 import { loadCodingAgentsConfig } from "../../../config/tools.js";
+import { saveSession } from "../../../config/index.js";
+import {
+  findLatestClaudeSession,
+  findLatestCodexSession,
+} from "../../../utils/session.js";
 import { createLogger } from "../../../logging/logger.js";
 
 const logger = createLogger({ category: "pty" });
@@ -47,12 +53,18 @@ export class PTYManager {
       bypassApprovals?: boolean;
       extraArgs?: string[];
       customToolId?: string | null;
+      resumeSessionId?: string | null;
     } = {},
   ): Promise<{ sessionId: string; session: CodingAgentSession }> {
     const cols = options.cols ?? 80;
     const rows = options.rows ?? 24;
     const toolName = options.toolName ?? null;
     const sessionId = randomUUID();
+    const startedAt = Date.now();
+    const resumeSessionId =
+      options.resumeSessionId && options.resumeSessionId.trim().length > 0
+        ? options.resumeSessionId.trim()
+        : null;
 
     logger.debug(
       { sessionId, toolType, mode, worktreePath, cols, rows },
@@ -65,6 +77,7 @@ export class PTYManager {
       bypassApprovals?: boolean;
       extraArgs?: string[];
       customToolId?: string | null;
+      sessionId?: string | null;
     } = {};
 
     if (toolName !== null) {
@@ -82,6 +95,9 @@ export class PTYManager {
     if (options.customToolId !== undefined) {
       resolverOptions.customToolId = options.customToolId;
     }
+    if (options.resumeSessionId !== undefined) {
+      resolverOptions.sessionId = options.resumeSessionId;
+    }
 
     const resolved = await this.resolveCommand(toolType, mode, resolverOptions);
 
@@ -153,6 +169,14 @@ export class PTYManager {
 
     this.instances.set(sessionId, { ptyProcess, session });
 
+    ptyProcess.onExit(() => {
+      void this.persistSessionIdOnExit({
+        session,
+        startedAt,
+        resumeSessionId,
+      });
+    });
+
     return { sessionId, session };
   }
 
@@ -230,6 +254,7 @@ export class PTYManager {
       bypassApprovals?: boolean;
       extraArgs?: string[];
       customToolId?: string | null;
+      sessionId?: string | null;
     },
   ): Promise<ResolvedCommand> {
     if (toolType === "custom") {
@@ -256,6 +281,7 @@ export class PTYManager {
         mode: "normal" | "continue" | "resume";
         bypassApprovals?: boolean;
         extraArgs?: string[];
+        sessionId?: string | null;
       } = { mode };
 
       if (options.bypassApprovals !== undefined) {
@@ -264,6 +290,9 @@ export class PTYManager {
       if (options.extraArgs && options.extraArgs.length > 0) {
         codexOptions.extraArgs = options.extraArgs;
       }
+      if (options.sessionId) {
+        codexOptions.sessionId = options.sessionId;
+      }
 
       return resolveCodexCommand(codexOptions);
     }
@@ -272,6 +301,7 @@ export class PTYManager {
       mode: "normal" | "continue" | "resume";
       skipPermissions?: boolean;
       extraArgs?: string[];
+      sessionId?: string | null;
     } = { mode };
 
     if (options.skipPermissions !== undefined) {
@@ -280,6 +310,9 @@ export class PTYManager {
     if (options.extraArgs && options.extraArgs.length > 0) {
       claudeOptions.extraArgs = options.extraArgs;
     }
+    if (options.sessionId) {
+      claudeOptions.sessionId = options.sessionId;
+    }
 
     return resolveClaudeCommand(claudeOptions);
   }
@@ -293,6 +326,77 @@ export class PTYManager {
     );
     return sharedEnv;
   }
+
+  private async persistSessionIdOnExit(params: {
+    session: CodingAgentSession;
+    startedAt: number;
+    resumeSessionId: string | null;
+  }): Promise<void> {
+    const { session, startedAt, resumeSessionId } = params;
+    if (
+      session.agentType !== "claude-code" &&
+      session.agentType !== "codex-cli"
+    ) {
+      return;
+    }
+
+    const finishedAt = Date.now();
+    let detectedSessionId: string | null = null;
+
+    try {
+      if (session.agentType === "codex-cli") {
+        const latest = await findLatestCodexSession({
+          since: startedAt - 60_000,
+          until: finishedAt + 60_000,
+          preferClosestTo: finishedAt,
+          windowMs: 60 * 60 * 1000,
+          cwd: session.worktreePath,
+        });
+        detectedSessionId = latest?.id ?? null;
+      } else if (session.agentType === "claude-code") {
+        const latest = await findLatestClaudeSession(session.worktreePath, {
+          since: startedAt - 60_000,
+          until: finishedAt + 60_000,
+          preferClosestTo: finishedAt,
+          windowMs: 60 * 60 * 1000,
+        });
+        detectedSessionId = latest?.id ?? null;
+      }
+    } catch (error: unknown) {
+      logger.debug(
+        { err: error, sessionId: session.sessionId },
+        "Failed to detect session ID",
+      );
+    }
+
+    const finalSessionId = detectedSessionId ?? resumeSessionId;
+    if (!finalSessionId) {
+      return;
+    }
+
+    try {
+      const context = await resolveGitContext(session.worktreePath);
+      if (!context.repoRoot) {
+        return;
+      }
+
+      await saveSession({
+        lastWorktreePath: session.worktreePath,
+        lastBranch: context.branchName,
+        lastUsedTool: session.agentType,
+        toolLabel: agentLabelFromType(session.agentType),
+        mode: session.mode,
+        timestamp: Date.now(),
+        repositoryRoot: context.repoRoot,
+        lastSessionId: finalSessionId,
+      });
+    } catch (error: unknown) {
+      logger.debug(
+        { err: error, sessionId: session.sessionId },
+        "Failed to persist session ID",
+      );
+    }
+  }
 }
 
 function isRootUser(): boolean {
@@ -302,3 +406,38 @@ function isRootUser(): boolean {
     return false;
   }
 }
+
+async function resolveGitContext(worktreePath: string): Promise<{
+  repoRoot: string | null;
+  branchName: string | null;
+}> {
+  try {
+    const { stdout: repoRoot } = await execa(
+      "git",
+      ["rev-parse", "--show-toplevel"],
+      { cwd: worktreePath },
+    );
+    const normalizedRoot = repoRoot.trim();
+    let branchName: string | null = null;
+    try {
+      const { stdout: branchStdout } = await execa(
+        "git",
+        ["rev-parse", "--abbrev-ref", "HEAD"],
+        { cwd: worktreePath },
+      );
+      branchName = branchStdout.trim() || null;
+    } catch {
+      branchName = null;
+    }
+
+    return { repoRoot: normalizedRoot || null, branchName };
+  } catch {
+    return { repoRoot: null, branchName: null };
+  }
+}
+
+function agentLabelFromType(agentType: "claude-code" | "codex-cli" | "custom") {
+  if (agentType === "claude-code") return "Claude";
+  if (agentType === "codex-cli") return "Codex";
+  return "Custom";
+}

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

@@ -60,6 +60,7 @@ export async function registerSessionRoutes(
         bypassApprovals,
         extraArgs,
         customAgentId,
+        resumeSessionId,
       } = request.body;
 
       logger.debug(
@@ -73,6 +74,7 @@ export async function registerSessionRoutes(
         bypassApprovals?: boolean;
         extraArgs?: string[];
         customToolId?: string | null;
+        resumeSessionId?: string | null;
       } = {};
 
       if (typeof agentName !== "undefined") {
@@ -90,6 +92,9 @@ export async function registerSessionRoutes(
       if (typeof customAgentId !== "undefined") {
         spawnOptions.customToolId = customAgentId;
       }
+      if (typeof resumeSessionId !== "undefined") {
+        spawnOptions.resumeSessionId = resumeSessionId;
+      }
 
       if (agentType === "custom" && !agentName && !customAgentId) {
         reply.code(400);
@@ -138,6 +143,7 @@ export async function registerSessionRoutes(
               ? (agentName ?? "Custom")
               : agentLabelFromType(agentType),
           mode,
+          lastSessionId: resumeSessionId ?? null,
           timestamp: Date.now(),
           repositoryRoot: repoRoot.trim(),
         });

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

@@ -58,7 +58,9 @@ export async function listBranches(): Promise<Branch[]> {
   const divergenceMap = await buildDivergenceMap(branches, repoRoot);
   const upstreamMap = await collectUpstreamMap(repoRoot);
   const baseCandidates = buildBaseBranchCandidates(branches);
-  const mainBranch = "main"; // TODO: 動的に取得
+  const branchNames = branches.map((b: BranchInfo) => b.name);
+  const mainBranch =
+    DEFAULT_BASE_BRANCHES.find((name) => branchNames.includes(name)) ?? "main";
   const refCache = new Map<string, boolean>();
   const ancestorCache = new Map<string, boolean>();
 
@@ -158,10 +160,9 @@ export async function syncBranchState(
     divergenceInput.branches = [sanitizedBranch];
   }
   const divergenceStatuses = await getBranchDivergenceStatuses(divergenceInput);
+  const firstDivergence = divergenceStatuses[0];
   const divergence =
-    divergenceStatuses.length > 0
-      ? mapDivergence(divergenceStatuses[0]!)
-      : null;
+    firstDivergence !== undefined ? mapDivergence(firstDivergence) : null;
 
   const branch = await getBranchByName(branchName);
   if (!branch) {
@@ -346,8 +347,9 @@ async function refExists(
   repoRoot: string,
   cache: Map<string, boolean>,
 ): Promise<boolean> {
-  if (cache.has(refName)) {
-    return cache.get(refName)!;
+  const cached = cache.get(refName);
+  if (cached !== undefined) {
+    return cached;
   }
 
   try {
@@ -367,8 +369,9 @@ async function isAncestorRef(
   cache: Map<string, boolean>,
 ): Promise<boolean> {
   const cacheKey = `${ancestor}->${branch}`;
-  if (cache.has(cacheKey)) {
-    return cache.get(cacheKey)!;
+  const cached = cache.get(cacheKey);
+  if (cached !== undefined) {
+    return cached;
   }
 
   try {

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

@@ -25,8 +25,8 @@ export async function listWorktrees(): Promise<Worktree[]> {
     path: wt.path,
     branchName: wt.branch,
     head: wt.head,
-    isLocked: false, // TODO: locked情報を取得
-    isPrunable: false, // TODO: prunable情報を取得
+    isLocked: wt.isLocked ?? false,
+    isPrunable: wt.isPrunable ?? false,
     isProtected: isProtectedBranchName(wt.branch),
     createdAt: null, // git worktreeからは取得不可
     lastAccessedAt: null, // git worktreeからは取得不可