@akiojin/gwt 2.11.1 → 2.12.1

package/dist/utils/session.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 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 declare function isValidUuidSessionId(id: string): boolean;
+export interface CodexSessionInfo {
+    id: string;
+    mtime: number;
+}
+export interface GeminiSessionInfo {
+    id: string;
+    mtime: number;
+}
+export declare function findLatestCodexSession(options?: {
+    since?: number;
+    until?: number;
+    preferClosestTo?: number;
+    windowMs?: number;
+    cwd?: string | null;
+}): Promise<CodexSessionInfo | null>;
+export declare function findLatestCodexSessionId(options?: {
+    since?: number;
+    until?: number;
+    preferClosestTo?: number;
+    windowMs?: number;
+    cwd?: string | null;
+}): Promise<string | null>;
+export declare function waitForCodexSessionId(options: {
+    startedAt: number;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    cwd?: string | null;
+}): Promise<string | null>;
+export declare function encodeClaudeProjectPath(cwd: string): string;
+export declare function findLatestClaudeSessionId(cwd: string, options?: {
+    since?: number;
+    until?: number;
+    preferClosestTo?: number;
+    windowMs?: number;
+}): Promise<string | null>;
+export interface ClaudeSessionInfo {
+    id: string;
+    mtime: number;
+}
+export declare function findLatestClaudeSession(cwd: string, options?: {
+    since?: number;
+    until?: number;
+    preferClosestTo?: number;
+    windowMs?: number;
+}): Promise<ClaudeSessionInfo | null>;
+export declare function waitForClaudeSessionId(cwd: string, options?: {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    since?: number;
+    until?: number;
+    preferClosestTo?: number;
+    windowMs?: number;
+}): Promise<string | null>;
+export declare function findLatestGeminiSession(_cwd: string, options?: {
+    since?: number;
+    until?: number;
+    preferClosestTo?: number;
+    windowMs?: number;
+    cwd?: string | null;
+}): Promise<GeminiSessionInfo | null>;
+export declare function findLatestGeminiSessionId(cwd: string, options?: {
+    since?: number;
+    until?: number;
+    preferClosestTo?: number;
+    windowMs?: number;
+    cwd?: string | null;
+}): Promise<string | null>;
+export declare function findLatestQwenSessionId(_cwd: string): Promise<string | 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 declare function claudeSessionFileExists(sessionId: string, worktreePath: string): Promise<boolean>;
+//# sourceMappingURL=session.d.ts.map

package/dist/utils/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/utils/session.ts"],"names":[],"mappings":"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"}

package/dist/utils/session.js

@@ -0,0 +1,579 @@
+import path from "node:path";
+import { homedir } from "node:os";
+import { readdir, readFile, stat } from "node:fs/promises";
+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) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
+}
+function pickSessionIdFromObject(obj) {
+    if (!obj || typeof obj !== "object")
+        return null;
+    const candidate = obj;
+    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();
+            // Only accept values that are valid UUIDs to avoid picking up arbitrary strings
+            if (isValidUuidSessionId(trimmed)) {
+                return trimmed;
+            }
+        }
+    }
+    return null;
+}
+function pickCwdFromObject(obj) {
+    if (!obj || typeof obj !== "object")
+        return null;
+    const candidate = obj;
+    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;
+}
+function pickSessionIdFromText(content) {
+    // 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;
+}
+async function findLatestFile(dir, filter) {
+    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) => Boolean(entry));
+        if (!valid.length)
+            return null;
+        valid.sort((a, b) => b.mtime - a.mtime);
+        return valid[0]?.fullPath ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function findNewestSessionIdFromDir(dir, recursive, options = {}) {
+    try {
+        const files = [];
+        const processDir = async (currentDir) => {
+            const currentEntries = await readdir(currentDir, { withFileTypes: true });
+            for (const entry of currentEntries) {
+                const fullPath = path.join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    if (recursive) {
+                        await processDir(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
+                }
+            }
+        };
+        await processDir(dir);
+        // Apply since/until filters clearly
+        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;
+}
+async function readSessionIdFromFile(filePath) {
+    try {
+        // Priority 1: Use filename UUID (most reliable for Claude session files)
+        // Claude session files are named with their session ID: {uuid}.jsonl
+        const basename = path.basename(filePath);
+        const filenameWithoutExt = basename.replace(/\.(json|jsonl)$/i, "");
+        if (isValidUuidSessionId(filenameWithoutExt)) {
+            return filenameWithoutExt;
+        }
+        // Priority 2: Extract from file content (for other formats)
+        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;
+    }
+}
+async function readSessionInfoFromFile(filePath) {
+    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 };
+}
+async function collectFilesRecursive(dir, filter) {
+    const results = [];
+    try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const nested = await collectFilesRecursive(fullPath, filter);
+                results.push(...nested);
+            }
+            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;
+}
+export async function findLatestCodexSession(options = {}) {
+    // 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 collectFilesRecursive(baseDir, (name) => name.endsWith(".json") || name.endsWith(".jsonl"));
+    if (!candidates.length)
+        return null;
+    const sinceFiltered = options.since
+        ? candidates.filter((c) => c.mtime >= options.since)
+        : candidates;
+    const bounded = options.until !== undefined
+        ? sinceFiltered.filter((c) => c.mtime <= options.until)
+        : sinceFiltered;
+    const hasWindow = options.since !== undefined || options.until !== undefined;
+    const pool = bounded.length ? bounded : hasWindow ? [] : sinceFiltered;
+    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)
+        // Codex filenames follow pattern: rollout-YYYY-MM-DDTHH-MM-SS-{uuid}.jsonl
+        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 (info.cwd &&
+                    // Match if: exact match, session cwd starts with options.cwd,
+                    // or options.cwd starts with session cwd (for worktree subdirectories)
+                    (info.cwd === options.cwd ||
+                        info.cwd.startsWith(options.cwd) ||
+                        options.cwd.startsWith(info.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 (info.cwd &&
+                // Match if: exact match, session cwd starts with options.cwd,
+                // or options.cwd starts with session cwd (for worktree subdirectories)
+                (info.cwd === options.cwd ||
+                    info.cwd.startsWith(options.cwd) ||
+                    options.cwd.startsWith(info.cwd))) {
+                return { id: info.id, mtime: file.mtime };
+            }
+            continue;
+        }
+        return { id: info.id, mtime: file.mtime };
+    }
+    return null;
+}
+export async function findLatestCodexSessionId(options = {}) {
+    const found = await findLatestCodexSession(options);
+    return found?.id ?? null;
+}
+export async function waitForCodexSessionId(options) {
+    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;
+}
+export function encodeClaudeProjectPath(cwd) {
+    // Normalize to forward slashes, drop drive colon, replace / and _ with -
+    const normalized = cwd.replace(/\\/g, "/").replace(/:/g, "");
+    return normalized.replace(/_/g, "-").replace(/\//g, "-");
+}
+function generateClaudeProjectPathCandidates(cwd) {
+    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));
+}
+export async function findLatestClaudeSessionId(cwd, options = {}) {
+    const found = await findLatestClaudeSession(cwd, options);
+    return found?.id ?? null;
+}
+export async function findLatestClaudeSession(cwd, options = {}) {
+    const rootCandidates = [];
+    if (process.env.CLAUDE_CONFIG_DIR) {
+        rootCandidates.push(process.env.CLAUDE_CONFIG_DIR);
+    }
+    rootCandidates.push(path.join(homedir(), ".claude"), path.join(homedir(), ".config", "claude"));
+    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) - prefer newest file with valid ID
+            const session = await findNewestSessionIdFromDir(sessionsDir, false, options);
+            if (session)
+                return session;
+            // 2) Look directly under project dir and subdirs (some versions emit files at root)
+            const rootSession = await findNewestSessionIdFromDir(projectDir, true, options);
+            if (rootSession)
+                return rootSession;
+        }
+    }
+    // Fallback: parse ~/.claude/history.jsonl (Claude Code global history)
+    try {
+        const historyPath = path.join(homedir(), ".claude", "history.jsonl");
+        const content = await readFile(historyPath, "utf-8");
+        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);
+                const project = typeof parsed.project === "string" ? parsed.project : null;
+                const sessionId = typeof parsed.sessionId === "string" ? parsed.sessionId : null;
+                if (project && sessionId && (project === cwd || cwd.startsWith(project))) {
+                    return { id: sessionId, mtime: Date.now() };
+                }
+            }
+            catch {
+                // ignore malformed lines
+            }
+        }
+    }
+    catch {
+        // ignore if history not present
+    }
+    return null;
+}
+export async function waitForClaudeSessionId(cwd, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    const pollIntervalMs = options.pollIntervalMs ?? 2_000;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const opt = {};
+        if (options.since !== undefined)
+            opt.since = options.since;
+        if (options.until !== undefined)
+            opt.until = options.until;
+        if (options.preferClosestTo !== undefined)
+            opt.preferClosestTo = options.preferClosestTo;
+        if (options.windowMs !== undefined)
+            opt.windowMs = options.windowMs;
+        const found = await findLatestClaudeSession(cwd, opt);
+        if (found?.id)
+            return found.id;
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    return null;
+}
+async function findLatestNestedSessionFile(baseDir, subPath, predicate) {
+    try {
+        const entries = await readdir(baseDir);
+        if (!entries.length)
+            return null;
+        const candidates = [];
+        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;
+    }
+}
+export async function findLatestGeminiSession(_cwd, options = {}) {
+    // Gemini stores sessions/logs under ~/.gemini/tmp/<project_hash>/(chats|logs).json
+    const baseDir = path.join(homedir(), ".gemini", "tmp");
+    const files = await collectFilesRecursive(baseDir, (name) => name.endsWith(".json") || name.endsWith(".jsonl"));
+    if (!files.length)
+        return null;
+    let pool = files;
+    if (options.since !== undefined) {
+        pool = pool.filter((f) => f.mtime >= options.since);
+    }
+    if (options.until !== undefined) {
+        pool = pool.filter((f) => f.mtime <= options.until);
+    }
+    const hasWindow = options.since !== undefined || options.until !== undefined;
+    if (!pool.length) {
+        if (!hasWindow) {
+            pool = files;
+        }
+        else {
+            return null;
+        }
+    }
+    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 (info.cwd &&
+                (info.cwd === options.cwd || info.cwd.startsWith(options.cwd))) {
+                return { id: info.id, mtime: file.mtime };
+            }
+            continue;
+        }
+        return { id: info.id, mtime: file.mtime };
+    }
+    return null;
+}
+export async function findLatestGeminiSessionId(cwd, options = {}) {
+    const normalized = {};
+    if (options.since !== undefined)
+        normalized.since = options.since;
+    if (options.until !== undefined)
+        normalized.until = options.until;
+    if (options.preferClosestTo !== undefined)
+        normalized.preferClosestTo = options.preferClosestTo;
+    if (options.windowMs !== undefined)
+        normalized.windowMs = options.windowMs;
+    const found = await findLatestGeminiSession(cwd, { ...normalized, cwd: options.cwd ?? cwd });
+    return found?.id ?? null;
+}
+export async function findLatestQwenSessionId(_cwd) {
+    // Qwen stores checkpoints/saves under ~/.qwen/tmp/<project_hash>/
+    const baseDir = path.join(homedir(), ".qwen", "tmp");
+    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(/\.[^.]+$/, "");
+}
+/**
+ * Returns the list of possible Claude root directories.
+ */
+function getClaudeRootCandidates() {
+    const roots = [];
+    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;
+}
+/**
+ * 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, worktreePath) {
+    if (!isValidUuidSessionId(sessionId)) {
+        return false;
+    }
+    const encodedPaths = generateClaudeProjectPathCandidates(worktreePath);
+    const roots = getClaudeRootCandidates();
+    for (const root of roots) {
+        for (const enc of encodedPaths) {
+            const candidate = path.join(root, "projects", enc, `${sessionId}.jsonl`);
+            try {
+                await stat(candidate);
+                return true;
+            }
+            catch {
+                // continue to next candidate
+            }
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=session.js.map