@akiojin/gwt 3.1.0 → 3.1.2

package/src/utils/session/parsers/claude.ts

@@ -0,0 +1,233 @@
+/**
+ * Claude Code session parser
+ *
+ * Handles session detection and management for Claude Code CLI.
+ * Session files are stored in ~/.claude/projects/<encoded-path>/sessions/
+ */
+
+import path from "node:path";
+import { homedir } from "node:os";
+
+import type { ClaudeSessionInfo, SessionSearchOptions } from "../types.js";
+import {
+  isValidUuidSessionId,
+  findNewestSessionIdFromDir,
+  matchesCwd,
+  readFileContent,
+  checkFileStat,
+} from "../common.js";
+
+/**
+ * Encodes a project path for Claude's directory structure.
+ * Normalizes separators and replaces special characters with dashes.
+ * @param cwd - The working directory path to encode
+ * @returns The encoded path string suitable for Claude's directory naming
+ */
+export function encodeClaudeProjectPath(cwd: string): string {
+  // Normalize to forward slashes, drop drive colon, replace / and _ with -
+  const normalized = cwd.replace(/\\/g, "/").replace(/:/g, "");
+  return normalized.replace(/_/g, "-").replace(/\//g, "-");
+}
+
+/**
+ * Generates candidate paths for Claude project directory.
+ * Handles various encoding patterns used by different Claude versions.
+ * @param cwd - The working directory path to encode
+ * @returns Array of possible encoded directory names
+ */
+function generateClaudeProjectPathCandidates(cwd: string): string[] {
+  const base = encodeClaudeProjectPath(cwd);
+  const dotToDash = cwd
+    .replace(/\\/g, "/")
+    .replace(/:/g, "")
+    .replace(/\./g, "-")
+    .replace(/_/g, "-")
+    .replace(/\//g, "-");
+  const collapsed = dotToDash.replace(/-+/g, "-");
+  const candidates = [base, dotToDash, collapsed];
+  return Array.from(new Set(candidates));
+}
+
+/**
+ * Returns the list of possible Claude root directories.
+ * Checks CLAUDE_CONFIG_DIR environment variable first, then falls back to
+ * standard locations (~/.claude and ~/.config/claude).
+ * @returns Array of possible Claude root directory paths
+ */
+function getClaudeRootCandidates(): string[] {
+  const roots: string[] = [];
+  if (process.env.CLAUDE_CONFIG_DIR) {
+    roots.push(process.env.CLAUDE_CONFIG_DIR);
+  }
+  roots.push(
+    path.join(homedir(), ".claude"),
+    path.join(homedir(), ".config", "claude"),
+  );
+  return roots;
+}
+
+/**
+ * Finds the latest Claude session for a given working directory.
+ *
+ * Search order:
+ * 1. ~/.claude/projects/<encoded>/sessions/ (official location)
+ * 2. ~/.claude/projects/<encoded>/ (root and subdirs)
+ * 3. ~/.claude/history.jsonl (global history fallback)
+ *
+ * @param cwd - The working directory to find sessions for
+ * @param options - Search options (since, until, preferClosestTo, windowMs)
+ * @returns Session info with ID and modification time, or null if not found
+ */
+export async function findLatestClaudeSession(
+  cwd: string,
+  options: Omit<SessionSearchOptions, "cwd"> = {},
+): Promise<ClaudeSessionInfo | null> {
+  const rootCandidates = getClaudeRootCandidates();
+  const encodedPaths = generateClaudeProjectPathCandidates(cwd);
+
+  for (const claudeRoot of rootCandidates) {
+    for (const encoded of encodedPaths) {
+      const projectDir = path.join(claudeRoot, "projects", encoded);
+      const sessionsDir = path.join(projectDir, "sessions");
+
+      // 1) Look under sessions/ (official location)
+      const session = await findNewestSessionIdFromDir(
+        sessionsDir,
+        false,
+        options,
+      );
+      if (session) return session;
+
+      // 2) Look directly under project dir and subdirs
+      const rootSession = await findNewestSessionIdFromDir(
+        projectDir,
+        true,
+        options,
+      );
+      if (rootSession) return rootSession;
+    }
+  }
+
+  // Fallback: parse ~/.claude/history.jsonl
+  try {
+    const historyPath = path.join(homedir(), ".claude", "history.jsonl");
+    const historyStat = await checkFileStat(historyPath);
+    if (!historyStat) return null;
+
+    const content = await readFileContent(historyPath);
+    const lines = content.split(/\r?\n/).filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+      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 && matchesCwd(project, cwd)) {
+          return { id: sessionId, mtime: historyStat.mtimeMs };
+        }
+      } catch {
+        // ignore malformed lines
+      }
+    }
+  } catch {
+    // ignore if history not present
+  }
+
+  return null;
+}
+
+/**
+ * Finds the latest Claude session ID for a given working directory.
+ * @param cwd - The working directory to find sessions for
+ * @param options - Search options (since, until, preferClosestTo, windowMs)
+ * @returns Session ID string or null if not found
+ */
+export async function findLatestClaudeSessionId(
+  cwd: string,
+  options: Omit<SessionSearchOptions, "cwd"> = {},
+): Promise<string | null> {
+  const found = await findLatestClaudeSession(cwd, options);
+  return found?.id ?? null;
+}
+
+/**
+ * Polls for a Claude session ID until found or timeout.
+ * @param cwd - The working directory to find sessions for
+ * @param options - Polling options including timeout, interval, and search filters
+ * @returns Session ID string or null if timeout reached
+ */
+export async function waitForClaudeSessionId(
+  cwd: string,
+  options: {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    since?: number;
+    until?: number;
+    preferClosestTo?: number;
+    windowMs?: number;
+  } = {},
+): Promise<string | null> {
+  const timeoutMs = options.timeoutMs ?? 120_000;
+  const pollIntervalMs = options.pollIntervalMs ?? 2_000;
+  const deadline = Date.now() + timeoutMs;
+
+  // Build search options once outside the loop
+  const searchOptions: Omit<SessionSearchOptions, "cwd"> = {};
+  if (options.since !== undefined) searchOptions.since = options.since;
+  if (options.until !== undefined) searchOptions.until = options.until;
+  if (options.preferClosestTo !== undefined)
+    searchOptions.preferClosestTo = options.preferClosestTo;
+  if (options.windowMs !== undefined) searchOptions.windowMs = options.windowMs;
+
+  while (Date.now() < deadline) {
+    const found = await findLatestClaudeSession(cwd, searchOptions);
+    if (found?.id) return found.id;
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+  return null;
+}
+
+/**
+ * Checks if a Claude session file exists for the given session ID and worktree path.
+ * @param sessionId - The session ID to check
+ * @param worktreePath - The worktree path (used to determine project encoding)
+ * @returns true if a session file exists for this ID
+ */
+export async function claudeSessionFileExists(
+  sessionId: string,
+  worktreePath: string,
+): Promise<boolean> {
+  if (!isValidUuidSessionId(sessionId)) {
+    return false;
+  }
+
+  const encodedPaths = generateClaudeProjectPathCandidates(worktreePath);
+  const roots = getClaudeRootCandidates();
+
+  for (const root of roots) {
+    for (const enc of encodedPaths) {
+      // Check official sessions/ location first
+      const sessionsCandidate = path.join(
+        root,
+        "projects",
+        enc,
+        "sessions",
+        `${sessionId}.jsonl`,
+      );
+      const sessionsInfo = await checkFileStat(sessionsCandidate);
+      if (sessionsInfo) {
+        return true;
+      }
+
+      // Then check project root
+      const candidate = path.join(root, "projects", enc, `${sessionId}.jsonl`);
+      const info = await checkFileStat(candidate);
+      if (info) {
+        return true;
+      }
+    }
+  }
+  return false;
+}

package/src/utils/session/parsers/codex.ts

@@ -0,0 +1,135 @@
+/**
+ * Codex CLI session parser
+ *
+ * Handles session detection and management for Codex CLI.
+ * Session files are stored in ~/.codex/sessions/ (or CODEX_HOME/sessions/).
+ * Filename pattern: rollout-YYYY-MM-DDTHH-MM-SS-{uuid}.jsonl
+ */
+
+import path from "node:path";
+import { homedir } from "node:os";
+
+import type { CodexSessionInfo, SessionSearchOptions } from "../types.js";
+import {
+  UUID_REGEX,
+  collectFilesIterative,
+  matchesCwd,
+  readSessionInfoFromFile,
+} from "../common.js";
+
+/**
+ * Finds the latest Codex session with optional time filtering and cwd matching.
+ *
+ * Session ID is extracted from:
+ * 1. Filename (rollout-...-{uuid}.jsonl) - most reliable
+ * 2. File content (payload.id or sessionId fields)
+ *
+ * @param options - Search options including time filters and cwd matching
+ * @returns Session info with ID and modification time, or null if not found
+ */
+export async function findLatestCodexSession(
+  options: SessionSearchOptions = {},
+): Promise<CodexSessionInfo | null> {
+  // Codex CLI respects CODEX_HOME. Default is ~/.codex.
+  const codexHome = process.env.CODEX_HOME ?? path.join(homedir(), ".codex");
+  const baseDir = path.join(codexHome, "sessions");
+  const candidates = await collectFilesIterative(
+    baseDir,
+    (name) => name.endsWith(".json") || name.endsWith(".jsonl"),
+  );
+  if (!candidates.length) return null;
+
+  // Apply time filters
+  let pool = candidates;
+  const sinceVal = options.since;
+  const untilVal = options.until;
+  if (sinceVal !== undefined) {
+    pool = pool.filter((c) => c.mtime >= sinceVal);
+  }
+  if (untilVal !== undefined) {
+    pool = pool.filter((c) => c.mtime <= untilVal);
+  }
+  if (!pool.length) return null;
+
+  const ref = options.preferClosestTo;
+  const window = options.windowMs ?? 30 * 60 * 1000; // 30 minutes default
+  const ordered = [...pool].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 ordered) {
+    // Priority 1: Extract session ID from filename (most reliable for Codex)
+    const filenameMatch = path.basename(file.fullPath).match(UUID_REGEX);
+    if (filenameMatch) {
+      const sessionId = filenameMatch[0];
+      // If cwd filtering is needed, read file content to check cwd
+      if (options.cwd) {
+        const info = await readSessionInfoFromFile(file.fullPath);
+        if (matchesCwd(info.cwd, options.cwd)) {
+          return { id: sessionId, mtime: file.mtime };
+        }
+        continue; // cwd doesn't match, try next file
+      }
+      return { id: sessionId, mtime: file.mtime };
+    }
+
+    // Priority 2: Fallback to reading file content if filename lacks UUID
+    const info = await readSessionInfoFromFile(file.fullPath);
+    if (!info.id) continue;
+    if (options.cwd) {
+      if (matchesCwd(info.cwd, options.cwd)) {
+        return { id: info.id, mtime: file.mtime };
+      }
+      continue;
+    }
+    return { id: info.id, mtime: file.mtime };
+  }
+
+  return null;
+}
+
+/**
+ * Finds the latest Codex session ID.
+ * @param options - Search options including time filters and cwd matching
+ * @returns Session ID string or null if not found
+ */
+export async function findLatestCodexSessionId(
+  options: SessionSearchOptions = {},
+): Promise<string | null> {
+  const found = await findLatestCodexSession(options);
+  return found?.id ?? null;
+}
+
+/**
+ * Polls for a Codex session ID until found or timeout.
+ * @param options - Polling options including startedAt time, timeout, and cwd filter
+ * @returns Session ID string or null if timeout reached
+ */
+export async function waitForCodexSessionId(options: {
+  startedAt: number;
+  timeoutMs?: number;
+  pollIntervalMs?: number;
+  cwd?: string | null;
+}): Promise<string | null> {
+  const timeoutMs = options.timeoutMs ?? 120_000;
+  const pollIntervalMs = options.pollIntervalMs ?? 2_000;
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() < deadline) {
+    const found = await findLatestCodexSession({
+      since: options.startedAt,
+      preferClosestTo: options.startedAt,
+      windowMs: 10 * 60 * 1000,
+      cwd: options.cwd ?? null,
+    });
+    if (found?.id) return found.id;
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+  return null;
+}

package/src/utils/session/parsers/gemini.ts

@@ -0,0 +1,94 @@
+/**
+ * Gemini CLI session parser
+ *
+ * Handles session detection for Gemini CLI.
+ * Session files are stored in ~/.gemini/tmp/<project_hash>/
+ */
+
+import path from "node:path";
+import { homedir } from "node:os";
+
+import type { GeminiSessionInfo, SessionSearchOptions } from "../types.js";
+import {
+  collectFilesIterative,
+  matchesCwd,
+  readSessionInfoFromFile,
+} from "../common.js";
+
+/**
+ * Finds the latest Gemini session with optional time filtering and cwd matching.
+ *
+ * @param options - Search options including time filters and cwd matching
+ * @returns Session info with ID and modification time, or null if not found
+ */
+export async function findLatestGeminiSession(
+  options: SessionSearchOptions = {},
+): Promise<GeminiSessionInfo | null> {
+  // Gemini stores sessions/logs under ~/.gemini/tmp/<project_hash>/
+  const baseDir = path.join(homedir(), ".gemini", "tmp");
+  const files = await collectFilesIterative(
+    baseDir,
+    (name) => name.endsWith(".json") || name.endsWith(".jsonl"),
+  );
+  if (!files.length) return null;
+
+  // Apply time filters
+  let pool = files;
+  const sinceVal = options.since;
+  if (sinceVal !== undefined) {
+    pool = pool.filter((f) => f.mtime >= sinceVal);
+  }
+  const untilVal = options.until;
+  if (untilVal !== undefined) {
+    pool = pool.filter((f) => f.mtime <= untilVal);
+  }
+  if (!pool.length) return null;
+
+  // Sort by preference or mtime
+  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;
+  });
+
+  for (const file of pool) {
+    const info = await readSessionInfoFromFile(file.fullPath);
+    if (!info.id) continue;
+    if (options.cwd) {
+      if (matchesCwd(info.cwd, options.cwd)) {
+        return { id: info.id, mtime: file.mtime };
+      }
+      continue;
+    }
+    return { id: info.id, mtime: file.mtime };
+  }
+
+  return null;
+}
+
+/**
+ * Finds the latest Gemini session ID.
+ * @param cwd - The working directory to find sessions for (used as fallback if options.cwd not set)
+ * @param options - Search options including time filters and cwd matching
+ * @returns Session ID string or null if not found
+ */
+export async function findLatestGeminiSessionId(
+  cwd: string,
+  options: SessionSearchOptions = {},
+): Promise<string | null> {
+  const searchOptions: SessionSearchOptions = { cwd: options.cwd ?? cwd };
+  if (options.since !== undefined) searchOptions.since = options.since;
+  if (options.until !== undefined) searchOptions.until = options.until;
+  if (options.preferClosestTo !== undefined)
+    searchOptions.preferClosestTo = options.preferClosestTo;
+  if (options.windowMs !== undefined) searchOptions.windowMs = options.windowMs;
+
+  const found = await findLatestGeminiSession(searchOptions);
+  return found?.id ?? null;
+}

package/src/utils/session/parsers/index.ts

@@ -0,0 +1,28 @@
+/**
+ * Session parsers - re-exports all tool-specific parsers
+ */
+
+// Claude Code
+export {
+  encodeClaudeProjectPath,
+  findLatestClaudeSession,
+  findLatestClaudeSessionId,
+  waitForClaudeSessionId,
+  claudeSessionFileExists,
+} from "./claude.js";
+
+// Codex CLI
+export {
+  findLatestCodexSession,
+  findLatestCodexSessionId,
+  waitForCodexSessionId,
+} from "./codex.js";
+
+// Gemini CLI
+export {
+  findLatestGeminiSession,
+  findLatestGeminiSessionId,
+} from "./gemini.js";
+
+// Qwen CLI
+export { findLatestQwenSessionId } from "./qwen.js";

package/src/utils/session/parsers/qwen.ts

@@ -0,0 +1,54 @@
+/**
+ * Qwen CLI session parser
+ *
+ * Handles session detection for Qwen CLI.
+ * Session files are stored in ~/.qwen/tmp/<project_hash>/
+ * and checkpoints in ~/.qwen/tmp/<project_hash>/checkpoints/
+ */
+
+import path from "node:path";
+import { homedir } from "node:os";
+
+import {
+  findLatestNestedSessionFile,
+  readSessionIdFromFile,
+} from "../common.js";
+
+/**
+ * Finds the latest Qwen session ID.
+ *
+ * Search order:
+ * 1. ~/.qwen/tmp/<hash>/*.json or *.jsonl
+ * 2. ~/.qwen/tmp/<hash>/checkpoints/*.json or *.ckpt
+ *
+ * Falls back to filename (without extension) if no session ID is found in content.
+ *
+ * @param _cwd - Working directory (currently unused, reserved for future per-project filtering)
+ * @returns Session ID string or null if not found
+ */
+export async function findLatestQwenSessionId(
+  _cwd: string,
+): Promise<string | null> {
+  const baseDir = path.join(homedir(), ".qwen", "tmp");
+
+  // Try root level first, then checkpoints subdirectory
+  const latest =
+    (await findLatestNestedSessionFile(
+      baseDir,
+      [],
+      (name) => name.endsWith(".json") || name.endsWith(".jsonl"),
+    )) ??
+    (await findLatestNestedSessionFile(
+      baseDir,
+      ["checkpoints"],
+      (name) => name.endsWith(".json") || name.endsWith(".ckpt"),
+    ));
+
+  if (!latest) return null;
+
+  const fromContent = await readSessionIdFromFile(latest);
+  if (fromContent) return fromContent;
+
+  // Fallback: use filename (without extension) as tag
+  return path.basename(latest).replace(/\.[^.]+$/, "");
+}

package/src/utils/session/types.ts

@@ -0,0 +1,42 @@
+/**
+ * Session types - common type definitions for session parsers
+ */
+
+/**
+ * Options for session search operations
+ */
+export interface SessionSearchOptions {
+  /** Minimum mtime (ms since epoch) */
+  since?: number;
+  /** Maximum mtime (ms since epoch) */
+  until?: number;
+  /** Reference time for preferring closest match */
+  preferClosestTo?: number;
+  /** Time window for closest match (default: 30 minutes) */
+  windowMs?: number;
+  /** Working directory filter */
+  cwd?: string | null;
+}
+
+/**
+ * Base session info with ID and modification time
+ */
+export interface SessionInfo {
+  id: string;
+  mtime: number;
+}
+
+/**
+ * Claude Code session info
+ */
+export type ClaudeSessionInfo = SessionInfo;
+
+/**
+ * Codex CLI session info
+ */
+export type CodexSessionInfo = SessionInfo;
+
+/**
+ * Gemini CLI session info
+ */
+export type GeminiSessionInfo = SessionInfo;