@asifkibria/claude-code-toolkit 1.3.1 → 1.4.2

package/dist/lib/dashboard.js

@@ -14,6 +14,9 @@ import { checkAlerts, checkQuotas } from "./alerts.js";
 import { linkSessionsToGit } from "./git.js";
 import { listLogFiles, parseAllLogs, getLogSummary } from "./logs.js";
 import { findAllJsonlFiles, findBackupFiles, scanFile, fixFile, getConversationStats, estimateContextSize, generateUsageAnalytics, findDuplicates, findArchiveCandidates, archiveConversations, runMaintenance, deleteOldBackups, restoreFromBackup, exportConversation, } from "./scanner.js";
+import { addBookmark, removeBookmark, getSessionBookmarks, renameSession, starSession, tagSession, addTagToSession, removeTagFromSession, getSessionTags, getAllTags, getStarredSessions, getBookmarksSummary, } from "./bookmarks.js";
+import { exportToHtml } from "./export.js";
+import { bulkDelete, bulkArchiveSessions, bulkExportSessions } from "./bulk.js";
 import { saveStorageSnapshot, listStorageSnapshots, loadStorageSnapshot, compareStorageSnapshots, deleteStorageSnapshot, // Missing export in storage.ts? I added it.
  } from "./storage.js";
 const CLAUDE_DIR = path.join(os.homedir(), ".claude");
@@ -43,7 +46,7 @@ function parseUrl(url) {
     }
     return { pathname, params };
 }
-function extractBearerToken(req, params, authToken) {
+function extractBearerToken(req, _params, authToken) {
     if (!authToken)
         return true;
     const header = req.headers["authorization"];
@@ -52,9 +55,6 @@ function extractBearerToken(req, params, authToken) {
         if (provided === authToken)
             return true;
     }
-    if (params?.token === authToken) {
-        return true;
-    }
     return false;
 }
 function rejectUnauthorized(res) {
@@ -78,9 +78,20 @@ function matchRoute(pathname, pattern) {
     return params;
 }
 function readBody(req) {
-    return new Promise((resolve) => {
+    const MAX_BODY_SIZE = 10 * 1024 * 1024;
+    return new Promise((resolve, reject) => {
         let data = "";
-        req.on("data", (chunk) => { data += chunk.toString(); });
+        let size = 0;
+        req.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > MAX_BODY_SIZE) {
+                req.destroy();
+                reject(new Error("Request body too large"));
+                return;
+            }
+            data += chunk.toString();
+        });
+        req.on("error", () => resolve({}));
         req.on("end", () => {
             try {
                 resolve(JSON.parse(data));
@@ -214,9 +225,11 @@ function getSecurity() {
 }
 function getSecurityFindingPreview(filePath, lineNum) {
     try {
-        const fullPath = path.join(PROJECTS_DIR, filePath);
-        const target = fs.existsSync(fullPath) ? fullPath : filePath;
-        if (!fs.existsSync(target))
+        const fullPath = path.resolve(PROJECTS_DIR, filePath);
+        if (!fullPath.startsWith(PROJECTS_DIR + path.sep) && fullPath !== PROJECTS_DIR)
+            return null;
+        const target = fs.existsSync(fullPath) ? fullPath : null;
+        if (!target)
             return null;
         const content = fs.readFileSync(target, "utf-8");
         const lines = content.split("\n");
@@ -989,6 +1002,43 @@ function actionPreviewTraces(body) {
     });
     return { success: true, ...preview };
 }
+function redactStringValue(text, patterns) {
+    let count = 0;
+    let result = text;
+    for (const pat of patterns) {
+        pat.regex.lastIndex = 0;
+        const before = result;
+        result = result.replace(pat.regex, "[REDACTED]");
+        if (result !== before)
+            count++;
+    }
+    return { result, count };
+}
+function redactInObject(obj, patterns) {
+    let totalCount = 0;
+    if (typeof obj === "string") {
+        const { result, count } = redactStringValue(obj, patterns);
+        return { result, count };
+    }
+    if (Array.isArray(obj)) {
+        const newArr = obj.map(item => {
+            const { result, count } = redactInObject(item, patterns);
+            totalCount += count;
+            return result;
+        });
+        return { result: newArr, count: totalCount };
+    }
+    if (obj && typeof obj === "object") {
+        const newObj = {};
+        for (const [key, value] of Object.entries(obj)) {
+            const { result, count } = redactInObject(value, patterns);
+            totalCount += count;
+            newObj[key] = result;
+        }
+        return { result: newObj, count: totalCount };
+    }
+    return { result: obj, count: 0 };
+}
 function actionRedact(body) {
     const file = body.file;
     const lineNum = body.line;
@@ -1012,11 +1062,24 @@ function actionRedact(body) {
     const line = lines[lineNum - 1];
     if (!line.trim())
         return { success: false, error: "Empty line" };
-    let redacted = line;
-    let count = 0;
     const patterns = patternType
         ? SECRET_PATTERNS.filter(p => p.type === patternType || p.name === patternType)
         : SECRET_PATTERNS;
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        parsed = {};
+    }
+    const { result: redactedObj, count: jsonCount } = redactInObject(parsed, patterns);
+    if (jsonCount > 0) {
+        lines[lineNum - 1] = JSON.stringify(redactedObj);
+        fs.writeFileSync(file, lines.join("\n"), "utf-8");
+        return { success: true, redactedCount: jsonCount, backupPath };
+    }
+    let redacted = line;
+    let count = 0;
     for (const pat of patterns) {
         pat.regex.lastIndex = 0;
         const before = redacted;
@@ -1044,6 +1107,10 @@ function actionRedactAll() {
     let secretsRedacted = 0;
     const errors = [];
     for (const [file, findings] of fileGroups) {
+        if (!fs.existsSync(file)) {
+            errors.push(`${file}: file no longer exists`);
+            continue;
+        }
         try {
             const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
             const backupPath = file.replace(".jsonl", `.backup.${timestamp}.jsonl`);
@@ -1058,17 +1125,32 @@ function actionRedactAll() {
                 processedLines.add(f.line);
                 if (f.line < 1 || f.line > lines.length)
                     continue;
-                let line = lines[f.line - 1];
+                const line = lines[f.line - 1];
+                let parsed = null;
+                try {
+                    parsed = JSON.parse(line);
+                }
+                catch { /* not valid JSON */ }
+                if (parsed) {
+                    const { result: redactedObj, count } = redactInObject(parsed, SECRET_PATTERNS);
+                    if (count > 0) {
+                        lines[f.line - 1] = JSON.stringify(redactedObj);
+                        secretsRedacted += count;
+                        modified = true;
+                        continue;
+                    }
+                }
+                let rawLine = line;
                 for (const pat of SECRET_PATTERNS) {
                     pat.regex.lastIndex = 0;
-                    const before = line;
-                    line = line.replace(pat.regex, "[REDACTED]");
-                    if (line !== before) {
+                    const before = rawLine;
+                    rawLine = rawLine.replace(pat.regex, "[REDACTED]");
+                    if (rawLine !== before) {
                         secretsRedacted++;
                         modified = true;
                     }
                 }
-                lines[f.line - 1] = line;
+                lines[f.line - 1] = rawLine;
             }
             if (modified) {
                 fs.writeFileSync(file, lines.join("\n"), "utf-8");
@@ -1235,7 +1317,7 @@ const getRoutes = {
     "/api/pii": (params) => {
         const limit = parseInt(params?.limit) || 50;
         const offset = parseInt(params?.offset) || 0;
-        const result = scanForPII(undefined, { includeFullValues: true });
+        const result = scanForPII(undefined, { includeFullValues: false });
         const paginatedFindings = result.findings.slice(offset, offset + limit);
         return {
             filesScanned: result.filesScanned,
@@ -1287,6 +1369,33 @@ const getRoutes = {
             return { error: "Snapshots not found" };
         const diff = compareStorageSnapshots(s1.analysis, s2.analysis);
         return { success: true, diff, baseDate: s1.date, currentDate: s2.date };
+    },
+    "/api/bookmarks": () => {
+        const summary = getBookmarksSummary();
+        const allTags = getAllTags();
+        const starred = getStarredSessions();
+        return { ...summary, allTags, starred };
+    },
+    "/api/bookmarks/starred": () => {
+        const starred = getStarredSessions();
+        const sessions = listSessions();
+        return starred.map(s => {
+            const session = sessions.find(sess => sess.id === s.sessionId || sess.id.startsWith(s.sessionId));
+            return {
+                ...s,
+                project: session?.project,
+                messageCount: session?.messageCount,
+                sizeBytes: session?.sizeBytes,
+            };
+        });
+    },
+    "/api/bookmarks/tags": () => getAllTags(),
+    "/api/session/:id/tags": (params) => {
+        const sessionId = params?.id;
+        if (!sessionId)
+            return { error: "Session ID required" };
+        const tags = getSessionTags(sessionId);
+        return tags || { sessionId, tags: [], starred: false };
     }
 };
 const postRoutes = {
@@ -1322,14 +1431,256 @@ const postRoutes = {
         if (!id)
             return { success: false, error: "ID required" };
         return { success: deleteStorageSnapshot(id) };
+    },
+    "/api/action/rename-session": (b) => {
+        const sessionId = b.sessionId;
+        const name = b.name;
+        if (!sessionId || !name)
+            return { success: false, error: "sessionId and name required" };
+        const result = renameSession(sessionId, name);
+        return { success: true, ...result };
+    },
+    "/api/action/star-session": (b) => {
+        const sessionId = b.sessionId;
+        const starred = b.starred !== false;
+        if (!sessionId)
+            return { success: false, error: "sessionId required" };
+        const result = starSession(sessionId, starred);
+        return { success: true, ...result };
+    },
+    "/api/action/tag-session": (b) => {
+        const sessionId = b.sessionId;
+        const tags = b.tags;
+        if (!sessionId)
+            return { success: false, error: "sessionId required" };
+        const result = tagSession(sessionId, { tags });
+        return { success: true, ...result };
+    },
+    "/api/action/add-tag": (b) => {
+        const sessionId = b.sessionId;
+        const tag = b.tag;
+        if (!sessionId || !tag)
+            return { success: false, error: "sessionId and tag required" };
+        const result = addTagToSession(sessionId, tag);
+        return { success: true, ...result };
+    },
+    "/api/action/remove-tag": (b) => {
+        const sessionId = b.sessionId;
+        const tag = b.tag;
+        if (!sessionId || !tag)
+            return { success: false, error: "sessionId and tag required" };
+        const result = removeTagFromSession(sessionId, tag);
+        return result ? { success: true, ...result } : { success: false, error: "Session tags not found" };
+    },
+    "/api/action/add-bookmark": (b) => {
+        const sessionId = b.sessionId;
+        const lineNumber = b.lineNumber;
+        const label = b.label;
+        const preview = b.preview;
+        if (!sessionId || !lineNumber)
+            return { success: false, error: "sessionId and lineNumber required" };
+        const result = addBookmark(sessionId, lineNumber, { label, preview });
+        return { success: true, bookmark: result };
+    },
+    "/api/action/remove-bookmark": (b) => {
+        const bookmarkId = b.bookmarkId;
+        if (!bookmarkId)
+            return { success: false, error: "bookmarkId required" };
+        const result = removeBookmark(bookmarkId);
+        return { success: result };
+    },
+    "/api/action/export-html": (b) => {
+        const sessionId = b.sessionId;
+        const theme = b.theme || "light";
+        if (!sessionId)
+            return { success: false, error: "sessionId required" };
+        const sessions = listSessions();
+        const session = sessions.find(s => s.id === sessionId || s.id.startsWith(sessionId));
+        if (!session)
+            return { success: false, error: "Session not found" };
+        const outputPath = session.filePath.replace(".jsonl", ".html");
+        const result = exportToHtml(session.filePath, outputPath, {
+            theme: theme === "dark" ? "dark" : "light",
+            includeTimestamps: true,
+            syntaxHighlighting: true,
+        });
+        return { success: true, file: result.file, messageCount: result.messageCount, size: result.size };
+    },
+    "/api/action/bulk-export": (b) => {
+        const projectFilter = b.projectFilter;
+        const format = b.format || "html";
+        const result = bulkExportSessions({
+            projectFilter,
+            format: format,
+        });
+        return { success: true, exported: result.exported.length, errors: result.errors.length, totalMessages: result.totalMessages };
+    },
+    "/api/action/bulk-delete": (b) => {
+        const days = b.days;
+        const projectFilter = b.projectFilter;
+        const dryRun = b.dryRun !== false;
+        const result = bulkDelete({
+            olderThanDays: days,
+            projectFilter,
+            dryRun,
+            includeStarred: false,
+        });
+        return { success: true, deleted: result.deleted.length, skipped: result.skipped.length, totalFreed: result.totalFreed, dryRun, errors: result.errors };
+    },
+    "/api/action/bulk-archive": (b) => {
+        const days = b.days;
+        const projectFilter = b.projectFilter;
+        const dryRun = b.dryRun !== false;
+        const result = bulkArchiveSessions({
+            olderThanDays: days,
+            projectFilter,
+            dryRun,
+            includeStarred: false,
+        });
+        return { success: true, archived: result.archived.length, skipped: result.skipped.length, totalSize: result.totalSize, dryRun, errors: result.errors };
+    },
+    "/api/action/purge-project": (b) => {
+        const projectFilter = b.projectFilter;
+        if (!projectFilter)
+            return { success: false, error: "projectFilter required" };
+        const deleteResult = bulkDelete({
+            projectFilter,
+            dryRun: false,
+            includeStarred: true,
+        });
+        let dirsRemoved = 0;
+        let dirFreedBytes = 0;
+        const dirErrors = [];
+        try {
+            const projectDirs = fs.readdirSync(PROJECTS_DIR);
+            for (const dir of projectDirs) {
+                if (dir.includes(projectFilter) || projectFilter.includes(dir)) {
+                    const dirPath = path.join(PROJECTS_DIR, dir);
+                    const stat = fs.statSync(dirPath);
+                    if (stat.isDirectory()) {
+                        const files = fs.readdirSync(dirPath);
+                        for (const file of files) {
+                            const filePath = path.join(dirPath, file);
+                            try {
+                                const fstat = fs.statSync(filePath);
+                                dirFreedBytes += fstat.size;
+                                fs.unlinkSync(filePath);
+                            }
+                            catch (e) {
+                                dirErrors.push(`${filePath}: ${e}`);
+                            }
+                        }
+                        try {
+                            fs.rmdirSync(dirPath);
+                            dirsRemoved++;
+                        }
+                        catch (e) {
+                            dirErrors.push(`rmdir ${dirPath}: ${e}`);
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) {
+            dirErrors.push(`readdir: ${e}`);
+        }
+        return {
+            success: true,
+            sessionsDeleted: deleteResult.deleted.length,
+            freedBytes: deleteResult.totalFreed + dirFreedBytes,
+            dirsRemoved,
+            errors: [...deleteResult.errors, ...dirErrors],
+        };
+    },
+    "/api/action/delete-files": (b) => {
+        const files = b.files;
+        if (!files || !Array.isArray(files) || files.length === 0) {
+            return { success: false, error: "files array required" };
+        }
+        let deleted = 0;
+        let freedBytes = 0;
+        const errors = [];
+        for (const filePath of files) {
+            try {
+                const resolved = path.resolve(filePath);
+                if (!resolved.startsWith(CLAUDE_DIR + path.sep)) {
+                    errors.push(`${filePath}: path outside Claude directory`);
+                    continue;
+                }
+                if (fs.existsSync(resolved)) {
+                    const stat = fs.statSync(resolved);
+                    freedBytes += stat.size;
+                    fs.unlinkSync(resolved);
+                    deleted++;
+                }
+            }
+            catch (e) {
+                errors.push(`${filePath}: ${e}`);
+            }
+        }
+        return { success: true, deleted, freedBytes, errors };
+    },
+    "/api/action/clean-category": (b) => {
+        const category = b.category;
+        if (!category)
+            return { success: false, error: "category required" };
+        const traces = inventoryTraces();
+        const cat = traces.categories.find(c => c.name === category);
+        if (!cat || !cat.items)
+            return { success: false, error: "Category not found" };
+        let deleted = 0;
+        let freedBytes = 0;
+        const errors = [];
+        for (const item of cat.items) {
+            try {
+                if (fs.existsSync(item.path)) {
+                    freedBytes += item.size;
+                    fs.unlinkSync(item.path);
+                    deleted++;
+                }
+            }
+            catch (e) {
+                errors.push(`${item.path}: ${e}`);
+            }
+        }
+        return { success: true, deleted, freedBytes, errors };
+    },
+    "/api/action/ignore-pii": (b) => {
+        const finding = b.finding;
+        if (!finding)
+            return { success: false, error: "finding required" };
+        const ignoreFile = path.join(os.homedir(), ".claude", "pii-ignore.json");
+        let ignoreList = [];
+        try {
+            if (fs.existsSync(ignoreFile)) {
+                ignoreList = JSON.parse(fs.readFileSync(ignoreFile, "utf-8"));
+            }
+        }
+        catch { /* ignore */ }
+        const pattern = finding.value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        if (!ignoreList.some(i => i.pattern === pattern)) {
+            ignoreList.push({ pattern, type: finding.type, reason: "User ignored" });
+            fs.writeFileSync(ignoreFile, JSON.stringify(ignoreList, null, 2));
+        }
+        return { success: true, ignored: pattern };
     }
 };
 export function createDashboardServer(authToken) {
     const html = generateDashboardHTML();
+    const CORS_HEADERS = {
+        "Access-Control-Allow-Origin": "http://localhost",
+        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Authorization, Content-Type",
+    };
     const server = http.createServer(async (req, res) => {
         const { pathname, params } = parseUrl(req.url || "/");
+        if (req.method === "OPTIONS") {
+            res.writeHead(204, CORS_HEADERS);
+            res.end();
+            return;
+        }
         if (req.method === "GET" && pathname === "/") {
-            res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+            res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", ...CORS_HEADERS });
             res.end(html);
             return;
         }
@@ -1384,11 +1735,11 @@ export function createDashboardServer(authToken) {
             if (handler) {
                 try {
                     const data = await handler(params);
-                    res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-cache" });
+                    res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-cache", ...CORS_HEADERS });
                     res.end(JSON.stringify(data));
                 }
                 catch (err) {
-                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.writeHead(500, { "Content-Type": "application/json", ...CORS_HEADERS });
                     res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
                 }
                 return;
@@ -1431,6 +1782,33 @@ export function createDashboardServer(authToken) {
                 }
                 return;
             }
+            const tagsMatch = matchRoute(pathname, "/api/session/:id/tags");
+            if (tagsMatch) {
+                try {
+                    const tags = getSessionTags(tagsMatch.id);
+                    const data = tags || { sessionId: tagsMatch.id, tags: [], starred: false };
+                    res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-cache" });
+                    res.end(JSON.stringify(data));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+                }
+                return;
+            }
+            const bookmarksMatch = matchRoute(pathname, "/api/session/:id/bookmarks");
+            if (bookmarksMatch) {
+                try {
+                    const bookmarks = getSessionBookmarks(bookmarksMatch.id);
+                    res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-cache" });
+                    res.end(JSON.stringify({ bookmarks }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+                }
+                return;
+            }
             const findingMatch = matchRoute(pathname, "/api/security/finding/:file/:line");
             if (findingMatch) {
                 try {