@akiojin/gwt 3.1.0 → 3.1.2

package/src/cli/ui/__tests__/components/screens/BranchListScreen.test.tsx

@@ -211,7 +211,46 @@ describe("BranchListScreen", () => {
     );
 
     const text = container.textContent ?? "";
-    expect(text).toMatch(/\[ \]\s(🟢|⚪)\s(🛡|⚠)/); // state cluster with spacing
+    expect(text).toMatch(/\[ \]\s(🟢|🔴|⚪)\s(🛡|⚠)/); // state cluster with spacing
+  });
+
+  it("should display 🔴 for inaccessible worktree", async () => {
+    const onSelect = vi.fn();
+    const branches: BranchItem[] = [
+      {
+        ...formatBranchItem({
+          name: "feature/missing-worktree",
+          type: "local",
+          branchType: "feature",
+          isCurrent: false,
+          hasUnpushedCommits: false,
+          worktree: {
+            path: "/tmp/wt-missing",
+            locked: false,
+            prunable: false,
+            isAccessible: false,
+          },
+        }),
+        safeToCleanup: false,
+      },
+    ];
+
+    let renderResult: ReturnType<typeof inkRender>;
+    await act(async () => {
+      renderResult = inkRender(
+        <BranchListScreen
+          branches={branches}
+          stats={mockStats}
+          onSelect={onSelect}
+        />,
+        { stripAnsi: false },
+      );
+    });
+
+    const frame = stripControlSequences(
+      stripAnsi(renderResult.lastFrame() ?? ""),
+    );
+    expect(frame).toContain("[ ] 🔴 ⚠");
   });
 
   it("should render last tool usage when available and Unknown when not", () => {

package/src/cli/ui/__tests__/utils/branchFormatter.test.ts

@@ -284,7 +284,7 @@ describe("branchFormatter", () => {
 
       const result = formatBranchItem(branchInfo);
 
-      expect(result.icons).toContain("🟠"); // inaccessible worktree icon
+      expect(result.icons).toContain("🔴"); // inaccessible worktree icon
       expect(result.icons).toContain("⚠️"); // warning icon
       expect(result.worktreeStatus).toBe("inaccessible");
     });

package/src/cli/ui/components/App.tsx

@@ -369,15 +369,17 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
             // For Gemini, prefer newest session file (Gemini keeps per-project chats)
             if (!sessionId && entry.toolId === "gemini-cli") {
               try {
-                const gemSession = await findLatestGeminiSession(worktree, {
-                  ...(entry.timestamp !== null && entry.timestamp !== undefined
-                    ? {
-                        since: entry.timestamp - 60_000,
-                        preferClosestTo: entry.timestamp,
-                      }
-                    : {}),
+                const gemOptions: Parameters<
+                  typeof findLatestGeminiSession
+                >[0] = {
                   windowMs: 60 * 60 * 1000,
-                });
+                  cwd: worktree,
+                };
+                if (entry.timestamp !== null && entry.timestamp !== undefined) {
+                  gemOptions.since = entry.timestamp - 60_000;
+                  gemOptions.preferClosestTo = entry.timestamp;
+                }
+                const gemSession = await findLatestGeminiSession(gemOptions);
                 sessionId = gemSession?.id ?? null;
               } catch {
                 // ignore

package/src/cli/ui/components/screens/BranchListScreen.tsx

@@ -27,7 +27,7 @@ const WIDTH_OVERRIDES: Record<string, number> = {
   // Worktree status icons
   "🟢": 2,
   "⚪": 2,
-  "🟠": 1,
+  "🔴": 2,
   // Change status icons
   "👉": 1,
   "💾": 1,
@@ -129,7 +129,7 @@ export function BranchListScreen({
   onToggleSelect,
 }: BranchListScreenProps) {
   const { rows } = useTerminalSize();
-  const headerText = "  Legend: [ ]/[ * ] select  🟢/⚪ worktree  🛡/⚠ safe";
+  const headerText = "  Legend: [ ]/[ * ] select  🟢/🔴/⚪ worktree  🛡/⚠ safe";
   const selectedSet = useMemo(
     () => new Set(selectedBranches),
     [selectedBranches],
@@ -406,10 +406,12 @@ export function BranchListScreen({
 
       const isChecked = selectedSet.has(item.name);
       const selectionIcon = isChecked ? "[*]" : "[ ]";
-      const hasWorktree =
-        item.worktreeStatus === "active" ||
-        item.worktreeStatus === "inaccessible";
-      const worktreeIcon = hasWorktree ? chalk.green("🟢") : chalk.gray("⚪");
+      let worktreeIcon = chalk.gray("⚪");
+      if (item.worktreeStatus === "active") {
+        worktreeIcon = chalk.green("🟢");
+      } else if (item.worktreeStatus === "inaccessible") {
+        worktreeIcon = chalk.red("🔴");
+      }
       const safeIcon =
         item.safeToCleanup === true ? chalk.green("🛡") : chalk.yellow("⚠");
       const stateCluster = `${selectionIcon} ${worktreeIcon} ${safeIcon}`;

package/src/cli/ui/utils/branchFormatter.ts

@@ -6,7 +6,6 @@ import type {
   WorktreeInfo,
 } from "../types.js";
 import stringWidth from "string-width";
-import chalk from "chalk";
 
 // Icon mappings
 const branchIcons: Record<BranchType, string> = {
@@ -21,7 +20,7 @@ const branchIcons: Record<BranchType, string> = {
 
 const worktreeIcons: Record<Exclude<WorktreeStatus, undefined>, string> = {
   active: "🟢",
-  inaccessible: "🟠",
+  inaccessible: "🔴",
 };
 
 const changeIcons = {
@@ -67,7 +66,7 @@ const iconWidthOverrides: Record<string, number> = {
   // Worktree status icons
   "🟢": 2,
   "⚪": 2,
-  "🟠": 1,
+  "🔴": 2,
   // Change status icons
   "👉": 1,
   "💾": 1,

package/src/index.ts

@@ -743,7 +743,7 @@ export async function handleAIToolWorkflow(
       }
     } else if (!finalSessionId && tool === "gemini-cli") {
       try {
-        const latestGemini = await findLatestGeminiSession(worktreePath, {
+        const latestGemini = await findLatestGeminiSession({
           since: launchStartedAt - 60_000,
           until: finishedAt + 60_000,
           preferClosestTo: finishedAt,

package/src/utils/session/common.ts

@@ -0,0 +1,446 @@
+/**
+ * Session common utilities - shared helper functions for session parsers
+ */
+
+import path from "node:path";
+import { readdir, readFile, stat } from "node:fs/promises";
+
+import type { SessionSearchOptions } from "./types.js";
+
+/**
+ * Regular expression for UUID matching
+ */
+export const UUID_REGEX =
+  /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+
+/**
+ * Validates that a string is a properly formatted UUID session ID.
+ * @param id - The string to validate
+ * @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,
+  );
+}
+
+/**
+ * Extracts session ID from an object by checking common key names.
+ * Only returns valid UUIDs.
+ */
+export function pickSessionIdFromObject(obj: unknown): string | null {
+  if (!obj || typeof obj !== "object") return null;
+  const candidate = obj as Record<string, unknown>;
+  const keys = ["sessionId", "session_id", "id", "conversation_id"];
+  for (const key of keys) {
+    const value = candidate[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      const trimmed = value.trim();
+      if (isValidUuidSessionId(trimmed)) {
+        return trimmed;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Extracts working directory from an object by checking common key names.
+ * Also checks nested payload object (for Codex session format).
+ */
+export 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",
+  ];
+  for (const key of keys) {
+    const value = candidate[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  // Check nested payload object (for Codex session format)
+  const payload = candidate["payload"];
+  if (payload && typeof payload === "object") {
+    const nested = pickCwdFromObject(payload);
+    if (nested) return nested;
+  }
+  return null;
+}
+
+/**
+ * Extracts session ID from text content.
+ * Tries JSON parsing first, then JSONL lines, then regex fallback.
+ */
+export function pickSessionIdFromText(content: string): string | null {
+  // Try whole content as JSON
+  try {
+    const parsed = JSON.parse(content);
+    const fromObject = pickSessionIdFromObject(parsed);
+    if (fromObject) return fromObject;
+  } catch {
+    // ignore
+  }
+
+  // Try JSONL lines
+  const lines = content.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsedLine = JSON.parse(trimmed);
+      const fromLine = pickSessionIdFromObject(parsedLine);
+      if (fromLine) return fromLine;
+    } catch {
+      // ignore
+    }
+    const match = trimmed.match(UUID_REGEX);
+    if (match) return match[0];
+  }
+
+  // Fallback: find any UUID in the whole text
+  const match = content.match(UUID_REGEX);
+  return match ? match[0] : null;
+}
+
+/**
+ * Finds the latest file in a directory matching a filter.
+ */
+export async function findLatestFile(
+  dir: string,
+  filter: (name: string) => boolean,
+): Promise<string | null> {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const files = entries.filter((e) => e.isFile()).map((e) => e.name);
+    const filtered = files.filter(filter);
+    if (!filtered.length) return null;
+
+    const withStats = await Promise.all(
+      filtered.map(async (name) => {
+        const fullPath = path.join(dir, name);
+        try {
+          const info = await stat(fullPath);
+          return { fullPath, mtime: info.mtimeMs };
+        } catch {
+          return null;
+        }
+      }),
+    );
+
+    const valid = withStats.filter(
+      (entry): entry is { fullPath: string; mtime: number } => Boolean(entry),
+    );
+    if (!valid.length) return null;
+
+    valid.sort((a, b) => b.mtime - a.mtime);
+    return valid[0]?.fullPath ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Collects files iteratively from a directory matching a filter.
+ * Uses queue-based iteration to avoid stack overflow on deep directory structures.
+ * @param dir - The root directory to search
+ * @param filter - Function to filter files by name
+ * @returns Array of matching files with their paths and modification times
+ */
+export async function collectFilesIterative(
+  dir: string,
+  filter: (name: string) => boolean,
+): Promise<{ fullPath: string; mtime: number }[]> {
+  const results: { fullPath: string; mtime: number }[] = [];
+  const queue: string[] = [dir];
+
+  while (queue.length > 0) {
+    const currentDir = queue.shift();
+    if (!currentDir) break;
+    try {
+      const entries = await readdir(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+          queue.push(fullPath);
+        } else if (entry.isFile() && filter(entry.name)) {
+          try {
+            const info = await stat(fullPath);
+            results.push({ fullPath, mtime: info.mtimeMs });
+          } catch {
+            // ignore unreadable file
+          }
+        }
+      }
+    } catch {
+      // ignore unreadable directory
+    }
+  }
+  return results;
+}
+
+/**
+ * Reads session ID from a file.
+ * Priority: filename UUID > file content > filename UUID fallback
+ */
+export async function readSessionIdFromFile(
+  filePath: string,
+): Promise<string | null> {
+  try {
+    // Priority 1: Use filename UUID (most reliable for Claude session files)
+    const basename = path.basename(filePath);
+    const filenameWithoutExt = basename.replace(/\.(json|jsonl)$/i, "");
+    if (isValidUuidSessionId(filenameWithoutExt)) {
+      return filenameWithoutExt;
+    }
+
+    // Priority 2: Extract from file content
+    const content = await readFile(filePath, "utf-8");
+    const fromContent = pickSessionIdFromText(content);
+    if (fromContent) return fromContent;
+
+    // Priority 3: Fallback to any UUID in filename
+    const filenameMatch = basename.match(UUID_REGEX);
+    return filenameMatch ? filenameMatch[0] : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Reads session info (ID and cwd) from a file.
+ */
+export async function readSessionInfoFromFile(
+  filePath: string,
+): Promise<{ id: string | null; cwd: string | null }> {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    try {
+      const parsed = JSON.parse(content);
+      const id = pickSessionIdFromObject(parsed);
+      const cwd = pickCwdFromObject(parsed);
+      if (id || cwd) return { id, cwd };
+    } catch {
+      // ignore
+    }
+
+    const lines = content.split(/\r?\n/);
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const parsedLine = JSON.parse(trimmed);
+        const id = pickSessionIdFromObject(parsedLine);
+        const cwd = pickCwdFromObject(parsedLine);
+        if (id || cwd) return { id, cwd };
+      } catch {
+        // ignore
+      }
+    }
+
+    // Fallback: filename UUID
+    const filenameMatch = path.basename(filePath).match(UUID_REGEX);
+    if (filenameMatch) return { id: filenameMatch[0], cwd: null };
+  } catch {
+    // ignore unreadable
+  }
+  return { id: null, cwd: null };
+}
+
+/**
+ * Finds newest session ID from a directory with optional time filtering.
+ * Uses queue-based iteration to avoid stack overflow on deep directory structures.
+ * @param dir - The root directory to search
+ * @param recursive - Whether to search subdirectories
+ * @param options - Search options (since, until, preferClosestTo, windowMs)
+ * @returns Session info with ID and modification time, or null if not found
+ */
+export async function findNewestSessionIdFromDir(
+  dir: string,
+  recursive: boolean,
+  options: Omit<SessionSearchOptions, "cwd"> = {},
+): Promise<{ id: string; mtime: number } | null> {
+  try {
+    const files: { fullPath: string; mtime: number }[] = [];
+    const queue: string[] = [dir];
+
+    // Queue-based directory traversal
+    while (queue.length > 0) {
+      const currentDir = queue.shift();
+      if (!currentDir) break;
+
+      try {
+        const entries = await readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path.join(currentDir, entry.name);
+          if (entry.isDirectory()) {
+            if (recursive) {
+              queue.push(fullPath);
+            }
+            continue;
+          }
+          if (!entry.isFile()) continue;
+          if (!entry.name.endsWith(".json") && !entry.name.endsWith(".jsonl"))
+            continue;
+          try {
+            const info = await stat(fullPath);
+            files.push({ fullPath, mtime: info.mtimeMs });
+          } catch {
+            // ignore unreadable file
+          }
+        }
+      } catch {
+        // ignore unreadable directory
+      }
+    }
+
+    // Apply since/until filters
+    const filtered = files.filter((f) => {
+      if (options.since !== undefined && f.mtime < options.since) return false;
+      if (options.until !== undefined && f.mtime > options.until) return false;
+      return true;
+    });
+
+    if (!filtered.length) return null;
+
+    // Sort by mtime descending (newest first)
+    let pool = filtered.sort((a, b) => b.mtime - a.mtime);
+
+    // Apply preferClosestTo window if specified
+    const ref = options.preferClosestTo;
+    if (typeof ref === "number") {
+      const window = options.windowMs ?? 30 * 60 * 1000;
+      const withinWindow = pool.filter(
+        (f) => Math.abs(f.mtime - ref) <= window,
+      );
+      if (withinWindow.length) {
+        pool = withinWindow.sort((a, b) => b.mtime - a.mtime);
+      }
+    }
+
+    for (const file of pool) {
+      const id = await readSessionIdFromFile(file.fullPath);
+      if (id) return { id, mtime: file.mtime };
+    }
+  } catch {
+    // ignore
+  }
+  return null;
+}
+
+/**
+ * Finds the latest nested session file from subdirectories.
+ */
+export async function findLatestNestedSessionFile(
+  baseDir: string,
+  subPath: string[],
+  predicate: (name: string) => boolean,
+): Promise<string | null> {
+  try {
+    const entries = await readdir(baseDir);
+    if (!entries.length) return null;
+
+    const candidates: { fullPath: string; mtime: number }[] = [];
+
+    for (const entry of entries) {
+      const dirPath = path.join(baseDir, entry, ...subPath);
+      const latest = await findLatestFile(dirPath, predicate);
+      if (latest) {
+        try {
+          const info = await stat(latest);
+          candidates.push({ fullPath: latest, mtime: info.mtimeMs });
+        } catch {
+          // ignore
+        }
+      }
+    }
+
+    if (!candidates.length) return null;
+    candidates.sort((a, b) => b.mtime - a.mtime);
+    return candidates[0]?.fullPath ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Reads text content from a file.
+ * Wrapper for fs.readFile to centralize fs operations for testability.
+ */
+export async function readFileContent(filePath: string): Promise<string> {
+  return readFile(filePath, "utf-8");
+}
+
+/**
+ * Checks if a file exists and returns stat info.
+ * Returns null if file does not exist.
+ */
+export async function checkFileStat(
+  filePath: string,
+): Promise<{ mtimeMs: number } | null> {
+  try {
+    const info = await stat(filePath);
+    return { mtimeMs: info.mtimeMs };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Normalizes a path for cross-platform comparison.
+ * Converts backslashes to forward slashes and resolves the path.
+ * @param p - The path to normalize
+ * @returns The normalized path string
+ */
+function normalizePath(p: string): string {
+  // Normalize separators to forward slashes for consistent comparison
+  return path.normalize(p).replace(/\\/g, "/");
+}
+
+/**
+ * Checks if one path is a proper prefix of another (with path separator boundary).
+ * Ensures that the prefix ends at a directory boundary to avoid false matches
+ * like "/home/user/proj" matching "/home/user/project".
+ * @param prefix - The potential prefix path
+ * @param full - The full path to check against
+ * @returns true if prefix is a valid path prefix of full
+ */
+function isPathPrefix(prefix: string, full: string): boolean {
+  if (!full.startsWith(prefix)) return false;
+  if (full.length === prefix.length) return true;
+  // Ensure the next character is a path separator
+  return full[prefix.length] === "/";
+}
+
+/**
+ * Checks if a session's cwd matches the target cwd.
+ * Matching rules:
+ * - Exact match
+ * - Session cwd starts with target cwd (session is in subdirectory)
+ * - Target cwd starts with session cwd (for worktree subdirectories)
+ *
+ * Paths are normalized before comparison to handle cross-platform differences.
+ * Path prefix matching ensures boundaries at directory separators.
+ *
+ * @param sessionCwd - The cwd from the session file
+ * @param targetCwd - The target cwd to match against
+ * @returns true if the cwd matches
+ */
+export function matchesCwd(
+  sessionCwd: string | null,
+  targetCwd: string,
+): boolean {
+  if (!sessionCwd) return false;
+  const normalizedSession = normalizePath(sessionCwd);
+  const normalizedTarget = normalizePath(targetCwd);
+  return (
+    normalizedSession === normalizedTarget ||
+    isPathPrefix(normalizedTarget, normalizedSession) ||
+    isPathPrefix(normalizedSession, normalizedTarget)
+  );
+}

package/src/utils/session/index.ts

@@ -0,0 +1,46 @@
+/**
+ * Session module - unified session management for AI tools
+ *
+ * This module provides session detection and management for various AI CLI tools:
+ * - Claude Code
+ * - Codex CLI
+ * - Gemini CLI
+ * - Qwen CLI
+ */
+
+// Type exports
+export type {
+  SessionSearchOptions,
+  SessionInfo,
+  ClaudeSessionInfo,
+  CodexSessionInfo,
+  GeminiSessionInfo,
+} from "./types.js";
+
+// Common utilities
+export { isValidUuidSessionId } from "./common.js";
+
+// Claude Code parser
+export {
+  encodeClaudeProjectPath,
+  findLatestClaudeSession,
+  findLatestClaudeSessionId,
+  waitForClaudeSessionId,
+  claudeSessionFileExists,
+} from "./parsers/claude.js";
+
+// Codex CLI parser
+export {
+  findLatestCodexSession,
+  findLatestCodexSessionId,
+  waitForCodexSessionId,
+} from "./parsers/codex.js";
+
+// Gemini CLI parser
+export {
+  findLatestGeminiSession,
+  findLatestGeminiSessionId,
+} from "./parsers/gemini.js";
+
+// Qwen CLI parser
+export { findLatestQwenSessionId } from "./parsers/qwen.js";