claudit 0.1.0

package/server/dist/server/src/services/ptyManager.js

@@ -0,0 +1,263 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import { WebSocket } from 'ws';
+import * as pty from 'node-pty';
+// Track active PTY sessions for status reporting
+const activePtySessions = new Set();
+export function getActivePtySessions() {
+    return activePtySessions;
+}
+// Resolve claude binary path at startup
+const CLAUDE_BIN = (() => {
+    try {
+        return execSync('which claude', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return 'claude';
+    }
+})();
+console.log(`[pty] Claude binary: ${CLAUDE_BIN}`);
+// Control message prefix — \x00 distinguishes control JSON from raw PTY data
+const CTRL_PREFIX = '\x00';
+function sendControl(ws, data) {
+    if (ws.readyState === WebSocket.OPEN) {
+        ws.send(CTRL_PREFIX + JSON.stringify(data));
+    }
+}
+function sendData(ws, data) {
+    if (ws.readyState === WebSocket.OPEN) {
+        ws.send(data);
+    }
+}
+const MAX_SCROLLBACK = 5000; // max chars to keep for replay
+const PTY_IDLE_TIMEOUT = 10 * 60 * 1000; // kill orphan PTY after 10 min
+const ptyCache = new Map();
+const idleTimers = new Map();
+function getPtyKey(sessionId, isNew) {
+    // For new sessions without a sessionId, generate a unique key
+    return sessionId || `new-${Date.now()}`;
+}
+function startIdleTimer(key) {
+    clearIdleTimer(key);
+    idleTimers.set(key, setTimeout(() => {
+        const entry = ptyCache.get(key);
+        if (entry && !entry.attachedWs) {
+            console.log(`[pty] Idle timeout, killing PTY: ${key}`);
+            destroyPty(key);
+        }
+    }, PTY_IDLE_TIMEOUT));
+}
+function clearIdleTimer(key) {
+    const timer = idleTimers.get(key);
+    if (timer) {
+        clearTimeout(timer);
+        idleTimers.delete(key);
+    }
+}
+function destroyPty(key) {
+    clearIdleTimer(key);
+    const entry = ptyCache.get(key);
+    if (entry) {
+        if (!entry.exited) {
+            try {
+                entry.process.kill();
+            }
+            catch { }
+        }
+        activePtySessions.delete(entry.sessionId);
+        ptyCache.delete(key);
+    }
+}
+function appendScrollback(entry, data) {
+    entry.scrollback.push(data);
+    // Trim if too large
+    let totalLen = 0;
+    for (const s of entry.scrollback)
+        totalLen += s.length;
+    while (totalLen > MAX_SCROLLBACK && entry.scrollback.length > 1) {
+        totalLen -= entry.scrollback.shift().length;
+    }
+}
+function spawnPty(key, sessionId, isNew, cwd, cols, rows) {
+    // Kill existing PTY for this key if any
+    if (ptyCache.has(key)) {
+        destroyPty(key);
+    }
+    const args = !isNew && sessionId
+        ? ['--resume', sessionId]
+        : [];
+    console.log(`[pty] Spawning: claude ${args.join(' ')} in ${cwd} (${cols}x${rows})`);
+    const process = pty.spawn(CLAUDE_BIN, args, {
+        name: 'xterm-256color',
+        cols: cols || 80,
+        rows: rows || 24,
+        cwd,
+        env: Object.fromEntries(Object.entries({ ...globalThis.process.env, TERM: 'xterm-256color' }).filter(([k]) => k !== 'CLAUDECODE')),
+    });
+    const entry = {
+        process,
+        sessionId,
+        scrollback: [],
+        attachedWs: null,
+        exited: false,
+        exitCode: null,
+    };
+    process.onData((data) => {
+        appendScrollback(entry, data);
+        if (entry.attachedWs) {
+            sendData(entry.attachedWs, data);
+        }
+    });
+    process.onExit(({ exitCode, signal }) => {
+        console.log(`[pty] Process exited: key=${key} code=${exitCode} signal=${signal}`);
+        entry.exited = true;
+        entry.exitCode = exitCode;
+        activePtySessions.delete(sessionId);
+        if (entry.attachedWs) {
+            sendControl(entry.attachedWs, { type: 'exit', exitCode, signal });
+        }
+        // Clean up after a delay so client can still see exit message
+        setTimeout(() => {
+            if (ptyCache.get(key) === entry) {
+                ptyCache.delete(key);
+                clearIdleTimer(key);
+            }
+        }, 60_000);
+    });
+    if (sessionId) {
+        activePtySessions.add(sessionId);
+    }
+    ptyCache.set(key, entry);
+    return entry;
+}
+function attachWs(entry, ws) {
+    // Detach previous ws if any
+    if (entry.attachedWs && entry.attachedWs !== ws) {
+        sendControl(entry.attachedWs, { type: 'detached' });
+    }
+    entry.attachedWs = ws;
+    clearIdleTimer(entry.sessionId);
+    // Replay scrollback so client sees recent output
+    if (entry.scrollback.length > 0) {
+        for (const chunk of entry.scrollback) {
+            sendData(ws, chunk);
+        }
+    }
+    // Tell client we're ready
+    if (entry.exited) {
+        sendControl(ws, { type: 'exit', exitCode: entry.exitCode, signal: 0 });
+    }
+    else {
+        sendControl(ws, { type: 'ready', sessionId: entry.sessionId });
+    }
+}
+function detachWs(entry, ws) {
+    if (entry.attachedWs === ws) {
+        entry.attachedWs = null;
+        // Start idle timer - don't kill immediately
+        if (!entry.exited) {
+            startIdleTimer(entry.sessionId);
+        }
+    }
+}
+// --- Public handler ---
+export function handleTerminalConnection(ws) {
+    console.log('[pty] Client connected');
+    let currentKey = null;
+    ws.on('message', (raw) => {
+        const str = raw.toString();
+        let msg;
+        try {
+            msg = JSON.parse(str);
+        }
+        catch {
+            // Raw terminal input
+            if (currentKey) {
+                const entry = ptyCache.get(currentKey);
+                if (entry && !entry.exited) {
+                    entry.process.write(str);
+                }
+            }
+            return;
+        }
+        switch (msg.type) {
+            case 'resume':
+            case 'new': {
+                const { sessionId, projectPath, cols, rows } = msg;
+                const isNew = msg.type === 'new';
+                const key = getPtyKey(sessionId, isNew);
+                const cwd = (projectPath && fs.existsSync(projectPath)) ? projectPath : os.homedir();
+                // Detach from previous PTY if switching
+                if (currentKey && currentKey !== key) {
+                    const prev = ptyCache.get(currentKey);
+                    if (prev)
+                        detachWs(prev, ws);
+                }
+                currentKey = key;
+                try {
+                    // Check if there's an existing alive PTY for this session
+                    const existing = ptyCache.get(key);
+                    if (existing && !existing.exited) {
+                        console.log(`[pty] Reattaching to existing PTY: ${key}`);
+                        // Resize to match new client
+                        try {
+                            existing.process.resize(cols || 80, rows || 24);
+                        }
+                        catch { }
+                        attachWs(existing, ws);
+                    }
+                    else {
+                        // Spawn new PTY
+                        const entry = spawnPty(key, sessionId, isNew, cwd, cols, rows);
+                        attachWs(entry, ws);
+                    }
+                }
+                catch (err) {
+                    console.error(`[pty] Spawn error: ${err.message}`);
+                    sendControl(ws, { type: 'error', message: err.message });
+                }
+                break;
+            }
+            case 'input': {
+                if (currentKey) {
+                    const entry = ptyCache.get(currentKey);
+                    if (entry && !entry.exited) {
+                        entry.process.write(msg.data);
+                    }
+                }
+                break;
+            }
+            case 'resize': {
+                if (currentKey && msg.cols && msg.rows) {
+                    const entry = ptyCache.get(currentKey);
+                    if (entry && !entry.exited) {
+                        try {
+                            entry.process.resize(msg.cols, msg.rows);
+                        }
+                        catch { }
+                    }
+                }
+                break;
+            }
+        }
+    });
+    ws.on('close', () => {
+        console.log('[pty] Client disconnected');
+        if (currentKey) {
+            const entry = ptyCache.get(currentKey);
+            if (entry)
+                detachWs(entry, ws);
+            currentKey = null;
+        }
+    });
+    ws.on('error', (err) => {
+        console.error(`[pty] WebSocket error: ${err.message}`);
+        if (currentKey) {
+            const entry = ptyCache.get(currentKey);
+            if (entry)
+                detachWs(entry, ws);
+            currentKey = null;
+        }
+    });
+}

package/server/dist/server/src/services/sessionIndexCache.js

@@ -0,0 +1,24 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { JsonStore } from './jsonStore.js';
+const INDEX_FILE = path.join(os.homedir(), '.claude', 'claudit-index.json');
+const indexStore = new JsonStore(INDEX_FILE, { sessions: {} });
+export function getSessionCache() {
+    return indexStore.read().sessions;
+}
+export function setSessionCache(sessions) {
+    indexStore.write({ sessions });
+}
+export function isSessionStale(sessionId, filePath, cache) {
+    const cached = cache[sessionId];
+    if (!cached)
+        return true;
+    try {
+        const stat = fs.statSync(filePath);
+        return stat.mtimeMs !== cached.fileMtime;
+    }
+    catch {
+        return true;
+    }
+}

package/server/dist/server/src/services/sessionParser.js

@@ -0,0 +1,98 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
+/** Normalize message content to ContentBlock[] */
+function normalizeContent(raw) {
+    if (!raw)
+        return [];
+    if (typeof raw === 'string') {
+        return [{ type: 'text', text: raw }];
+    }
+    if (Array.isArray(raw)) {
+        return raw;
+    }
+    return [{ type: 'text', text: JSON.stringify(raw) }];
+}
+/** Check if a user message is just tool_result (internal exchange, not user-typed) */
+function isToolResultOnly(content) {
+    return content.length > 0 && content.every(c => c.type === 'tool_result');
+}
+export function parseSession(projectHash, sessionId) {
+    const filePath = path.join(PROJECTS_DIR, projectHash, `${sessionId}.jsonl`);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Session file not found: ${filePath}`);
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    // We need to merge assistant records with the same message.id
+    const messagesById = new Map();
+    const orderedMessages = [];
+    let projectPath = projectHash;
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        // Capture project path from first record with cwd
+        if (record.cwd && projectPath === projectHash) {
+            projectPath = record.cwd;
+        }
+        // Skip non-message records
+        if (record.type !== 'user' && record.type !== 'assistant')
+            continue;
+        if (record.isMeta)
+            continue;
+        if (!record.message?.content)
+            continue;
+        const normalizedContent = normalizeContent(record.message.content);
+        if (record.type === 'user') {
+            // Skip pure tool_result messages (internal tool exchange)
+            if (isToolResultOnly(normalizedContent))
+                continue;
+            // Only keep user messages that have actual text content
+            const hasText = normalizedContent.some(c => c.type === 'text' && c.text?.trim());
+            if (!hasText)
+                continue;
+            const msg = {
+                uuid: record.uuid || crypto.randomUUID(),
+                role: 'user',
+                timestamp: record.timestamp || new Date().toISOString(),
+                content: normalizedContent.filter(c => c.type === 'text'),
+            };
+            orderedMessages.push(msg);
+        }
+        else if (record.type === 'assistant') {
+            const msgId = record.message.id;
+            if (!msgId)
+                continue;
+            const existing = messagesById.get(msgId);
+            if (existing) {
+                // Merge: use latest (most complete) content
+                existing.content = normalizedContent;
+            }
+            else {
+                const msg = {
+                    uuid: record.uuid || crypto.randomUUID(),
+                    role: 'assistant',
+                    timestamp: record.timestamp || new Date().toISOString(),
+                    content: normalizedContent,
+                    model: record.message.model,
+                    messageId: msgId,
+                };
+                messagesById.set(msgId, msg);
+                orderedMessages.push(msg);
+            }
+        }
+    }
+    return {
+        sessionId,
+        projectPath,
+        messages: orderedMessages,
+    };
+}

package/server/dist/server/src/services/sessionScanner.js

@@ -0,0 +1,244 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { getManagedSessionMap } from './managedSessions.js';
+import { getSessionCache, setSessionCache, isSessionStale } from './sessionIndexCache.js';
+export const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+export const PROJECTS_DIR = path.join(CLAUDE_DIR, 'projects');
+export const HISTORY_FILE = path.join(CLAUDE_DIR, 'history.jsonl');
+/** Build history index from history.jsonl, also builds projectHash -> real path map */
+export function readHistoryEntries() {
+    const entries = new Map();
+    const projectPaths = new Map();
+    if (!fs.existsSync(HISTORY_FILE))
+        return { entries, projectPaths };
+    const content = fs.readFileSync(HISTORY_FILE, 'utf-8');
+    for (const line of content.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const entry = JSON.parse(line);
+            const existing = entries.get(entry.sessionId);
+            if (!existing || entry.timestamp > existing.timestamp) {
+                entries.set(entry.sessionId, entry);
+            }
+            if (entry.project) {
+                const hash = entry.project.replace(/\//g, '-');
+                projectPaths.set(hash, entry.project);
+            }
+        }
+        catch {
+            // skip malformed lines
+        }
+    }
+    return { entries, projectPaths };
+}
+/** Try to get project path (cwd) from session JSONL file */
+export function getProjectPathFromSession(sessionFile) {
+    try {
+        const content = fs.readFileSync(sessionFile, 'utf-8');
+        for (const line of content.split('\n').slice(0, 10)) {
+            if (!line.trim())
+                continue;
+            try {
+                const record = JSON.parse(line);
+                if (record.cwd)
+                    return record.cwd;
+            }
+            catch {
+                // skip malformed
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Try to extract the first user message from a session JSONL file */
+export function getFirstUserMessage(sessionFile) {
+    try {
+        const content = fs.readFileSync(sessionFile, 'utf-8');
+        for (const line of content.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const record = JSON.parse(line);
+                if (record.type !== 'user')
+                    continue;
+                const msg = record.message;
+                if (!msg?.content)
+                    continue;
+                if (typeof msg.content === 'string')
+                    return msg.content;
+                if (Array.isArray(msg.content)) {
+                    const hasNonToolResult = msg.content.some((b) => b.type === 'text' || (b.type !== 'tool_result'));
+                    if (!hasNonToolResult)
+                        continue;
+                    for (const block of msg.content) {
+                        if (block.type === 'text' && block.text)
+                            return block.text;
+                    }
+                }
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Quick-count user and assistant type lines in a session file */
+export function countMessages(sessionFile) {
+    try {
+        const content = fs.readFileSync(sessionFile, 'utf-8');
+        let count = 0;
+        for (const line of content.split('\n')) {
+            if (!line.trim())
+                continue;
+            if (line.includes('"type":"user"') || line.includes('"type":"assistant"')) {
+                try {
+                    const record = JSON.parse(line);
+                    if (record.type === 'user' || record.type === 'assistant') {
+                        count++;
+                    }
+                }
+                catch {
+                    // skip malformed
+                }
+            }
+        }
+        return count;
+    }
+    catch {
+        return 0;
+    }
+}
+/** Read from end of file to find last user/assistant record type */
+export function getLastSignificantRecordType(sessionFile) {
+    try {
+        const content = fs.readFileSync(sessionFile, 'utf-8');
+        const lines = content.split('\n');
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            try {
+                const record = JSON.parse(line);
+                if (record.type === 'user' || record.type === 'assistant') {
+                    return record.type;
+                }
+            }
+            catch {
+                // skip malformed
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Scan projects directory to find all session files, using mtime-based cache */
+export function scanProjectSessions() {
+    const summaries = [];
+    if (!fs.existsSync(PROJECTS_DIR))
+        return summaries;
+    const { entries: historyEntries, projectPaths } = readHistoryEntries();
+    const managedMap = getManagedSessionMap();
+    const projectDirs = fs.readdirSync(PROJECTS_DIR, { withFileTypes: true });
+    const indexCache = getSessionCache();
+    const updatedCache = { ...indexCache };
+    let cacheModified = false;
+    for (const dir of projectDirs) {
+        if (!dir.isDirectory())
+            continue;
+        const projectHash = dir.name;
+        const projectDir = path.join(PROJECTS_DIR, projectHash);
+        const files = fs.readdirSync(projectDir).filter(f => f.endsWith('.jsonl'));
+        let projectPath = projectPaths.get(projectHash) || '';
+        for (const file of files) {
+            const sessionId = file.replace('.jsonl', '');
+            const historyEntry = historyEntries.get(sessionId);
+            const filePath = path.join(projectDir, file);
+            if (!projectPath && historyEntry?.project) {
+                projectPath = historyEntry.project;
+            }
+            if (!projectPath) {
+                projectPath = getProjectPathFromSession(filePath) || projectHash;
+            }
+            let lastMessage;
+            let timestamp;
+            let messageCount;
+            let lastRecordType;
+            if (!isSessionStale(sessionId, filePath, indexCache)) {
+                // Use cached data
+                const cached = indexCache[sessionId];
+                lastMessage = cached.lastMessage;
+                timestamp = cached.timestamp;
+                messageCount = cached.messageCount;
+                lastRecordType = cached.lastRecordType;
+                // Update projectPath from cache if not yet resolved
+                if (!projectPath || projectPath === projectHash) {
+                    projectPath = cached.projectPath;
+                }
+            }
+            else {
+                // Full scan
+                if (historyEntry) {
+                    timestamp = historyEntry.timestamp;
+                    lastMessage = historyEntry.display;
+                }
+                else {
+                    const stat = fs.statSync(filePath);
+                    timestamp = stat.mtimeMs;
+                    lastMessage = getFirstUserMessage(filePath) || sessionId.slice(0, 8) + '...';
+                }
+                if (lastMessage.length > 100) {
+                    lastMessage = lastMessage.slice(0, 100) + '...';
+                }
+                messageCount = countMessages(filePath);
+                lastRecordType = messageCount > 0 ? getLastSignificantRecordType(filePath) : null;
+                // Update cache
+                try {
+                    const stat = fs.statSync(filePath);
+                    updatedCache[sessionId] = {
+                        projectHash,
+                        projectPath,
+                        lastMessage,
+                        timestamp,
+                        messageCount,
+                        lastRecordType,
+                        fileMtime: stat.mtimeMs,
+                    };
+                    cacheModified = true;
+                }
+                catch {
+                    // ignore stat error
+                }
+            }
+            let status = 'idle';
+            if (messageCount > 0 && lastRecordType === 'assistant') {
+                status = 'need_attention';
+            }
+            const managed = managedMap.get(sessionId);
+            summaries.push({
+                sessionId,
+                projectPath,
+                projectHash,
+                lastMessage,
+                timestamp,
+                messageCount,
+                displayName: managed?.displayName,
+                status,
+            });
+        }
+    }
+    if (cacheModified) {
+        setSessionCache(updatedCache);
+    }
+    return summaries;
+}