claude-chrome-parallel 2.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/types/session.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,oBAAoB;IACnC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,iBAAiB,GAAG,iBAAiB,GAAG,sBAAsB,GAAG,wBAAwB,CAAC;IAChG,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/types/session.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Session Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=session.js.map

package/dist/types/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","sourceRoot":"","sources":["../../src/types/session.ts"],"names":[],"mappings":";AAAA;;GAEG"}

package/dist/utils/atomic-file.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Atomic file operations for safe concurrent access
+ * Prevents race conditions when multiple processes access the same file
+ */
+export interface WriteOptions {
+    /** Create backup before writing */
+    backup?: boolean;
+    /** Timeout for acquiring lock (ms) */
+    lockTimeout?: number;
+}
+export interface ReadResult<T> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    corrupted?: boolean;
+}
+/**
+ * Write file atomically using temp file + rename pattern
+ * This ensures the file is never in a partial/corrupt state
+ */
+export declare function writeFileAtomicSafe(filePath: string, data: string | object, options?: WriteOptions): Promise<void>;
+/**
+ * Read file safely with JSON validation
+ */
+export declare function readFileSafe<T = unknown>(filePath: string): Promise<ReadResult<T>>;
+/**
+ * Create a backup of a file
+ */
+export declare function backupFile(filePath: string, backupDir?: string): Promise<string>;
+/**
+ * Restore a file from backup
+ */
+export declare function restoreFromBackup(backupPath: string, targetPath: string): Promise<void>;
+/**
+ * Get list of available backups for a file
+ */
+export declare function listBackups(originalFilename: string, backupDir?: string): string[];
+/**
+ * Clean up old backups, keeping only the specified number
+ */
+export declare function cleanupBackups(originalFilename: string, keepCount?: number, backupDir?: string): number;
+/**
+ * Acquire a file lock with timeout
+ */
+export declare function acquireLock(filePath: string, timeout?: number): Promise<() => Promise<void>>;
+/**
+ * Check if a file is currently locked
+ */
+export declare function isLocked(filePath: string): Promise<boolean>;
+//# sourceMappingURL=atomic-file.d.ts.map

package/dist/utils/atomic-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic-file.d.ts","sourceRoot":"","sources":["../../src/utils/atomic-file.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,MAAM,WAAW,YAAY;IAC3B,mCAAmC;IACnC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,sCAAsC;IACtC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,CAAC,GAAG,OAAO,EAC5C,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAgCxB;AAED;;GAEG;AACH,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,CA4BjB;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CAcf;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,gBAAgB,EAAE,MAAM,EACxB,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,EAAE,CAoBV;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,gBAAgB,EAAE,MAAM,EACxB,SAAS,GAAE,MAAU,EACrB,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CAqBR;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,MAAc,GACtB,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAoB9B;AAED;;GAEG;AACH,wBAAsB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAKjE"}

package/dist/utils/atomic-file.js

@@ -0,0 +1,217 @@
+"use strict";
+/**
+ * Atomic file operations for safe concurrent access
+ * Prevents race conditions when multiple processes access the same file
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFileAtomicSafe = writeFileAtomicSafe;
+exports.readFileSafe = readFileSafe;
+exports.backupFile = backupFile;
+exports.restoreFromBackup = restoreFromBackup;
+exports.listBackups = listBackups;
+exports.cleanupBackups = cleanupBackups;
+exports.acquireLock = acquireLock;
+exports.isLocked = isLocked;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const write_file_atomic_1 = __importDefault(require("write-file-atomic"));
+const lockfile = __importStar(require("proper-lockfile"));
+/**
+ * Write file atomically using temp file + rename pattern
+ * This ensures the file is never in a partial/corrupt state
+ */
+async function writeFileAtomicSafe(filePath, data, options = {}) {
+    const { backup = false, lockTimeout = 10000 } = options;
+    const content = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+    // Ensure directory exists
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    // Create backup if requested and file exists
+    if (backup && fs.existsSync(filePath)) {
+        await backupFile(filePath);
+    }
+    // Use write-file-atomic for safe writing
+    await (0, write_file_atomic_1.default)(filePath, content, { encoding: 'utf8' });
+}
+/**
+ * Read file safely with JSON validation
+ */
+async function readFileSafe(filePath) {
+    try {
+        if (!fs.existsSync(filePath)) {
+            return { success: false, error: 'File does not exist' };
+        }
+        const content = fs.readFileSync(filePath, 'utf8');
+        // Try to parse as JSON
+        try {
+            const data = JSON.parse(content);
+            return { success: true, data };
+        }
+        catch (parseError) {
+            // Check if it's a corruption pattern (two JSON objects concatenated)
+            if (content.includes('}{')) {
+                return {
+                    success: false,
+                    error: 'JSON parse error - corruption detected',
+                    corrupted: true,
+                };
+            }
+            return {
+                success: false,
+                error: `JSON parse error: ${parseError.message}`,
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Read error: ${error.message}`,
+        };
+    }
+}
+/**
+ * Create a backup of a file
+ */
+async function backupFile(filePath, backupDir) {
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`File does not exist: ${filePath}`);
+    }
+    // Default backup directory
+    const defaultBackupDir = path.join(os.homedir(), '.claude-chrome-parallel', 'backups');
+    const targetDir = backupDir || defaultBackupDir;
+    // Ensure backup directory exists
+    if (!fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+    }
+    // Generate backup filename with timestamp
+    const basename = path.basename(filePath);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupName = `${basename}.${timestamp}.bak`;
+    const backupPath = path.join(targetDir, backupName);
+    // Copy file to backup location
+    fs.copyFileSync(filePath, backupPath);
+    return backupPath;
+}
+/**
+ * Restore a file from backup
+ */
+async function restoreFromBackup(backupPath, targetPath) {
+    if (!fs.existsSync(backupPath)) {
+        throw new Error(`Backup file does not exist: ${backupPath}`);
+    }
+    // Ensure target directory exists
+    const targetDir = path.dirname(targetPath);
+    if (!fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+    }
+    // Use atomic write to restore
+    const content = fs.readFileSync(backupPath, 'utf8');
+    await writeFileAtomicSafe(targetPath, content);
+}
+/**
+ * Get list of available backups for a file
+ */
+function listBackups(originalFilename, backupDir) {
+    const defaultBackupDir = path.join(os.homedir(), '.claude-chrome-parallel', 'backups');
+    const targetDir = backupDir || defaultBackupDir;
+    if (!fs.existsSync(targetDir)) {
+        return [];
+    }
+    const basename = path.basename(originalFilename);
+    const pattern = new RegExp(`^${basename.replace('.', '\\.')}\\..*\\.bak$`);
+    return fs
+        .readdirSync(targetDir)
+        .filter((file) => pattern.test(file))
+        .sort()
+        .reverse(); // Most recent first
+}
+/**
+ * Clean up old backups, keeping only the specified number
+ */
+function cleanupBackups(originalFilename, keepCount = 5, backupDir) {
+    const backups = listBackups(originalFilename, backupDir);
+    const toDelete = backups.slice(keepCount);
+    const defaultBackupDir = path.join(os.homedir(), '.claude-chrome-parallel', 'backups');
+    const targetDir = backupDir || defaultBackupDir;
+    for (const backup of toDelete) {
+        const backupPath = path.join(targetDir, backup);
+        try {
+            fs.unlinkSync(backupPath);
+        }
+        catch {
+            // Ignore deletion errors
+        }
+    }
+    return toDelete.length;
+}
+/**
+ * Acquire a file lock with timeout
+ */
+async function acquireLock(filePath, timeout = 10000) {
+    // Ensure file exists for locking
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, '{}');
+    }
+    const release = await lockfile.lock(filePath, {
+        retries: {
+            retries: Math.ceil(timeout / 100),
+            factor: 1,
+            minTimeout: 100,
+            maxTimeout: 100,
+        },
+    });
+    return release;
+}
+/**
+ * Check if a file is currently locked
+ */
+async function isLocked(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return false;
+    }
+    return lockfile.check(filePath);
+}
+//# sourceMappingURL=atomic-file.js.map

package/dist/utils/atomic-file.js.map

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

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Utility exports
+ */
+export * from './atomic-file';
+export * from './json-validator';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Utility exports
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./atomic-file"), exports);
+__exportStar(require("./json-validator"), exports);
+//# sourceMappingURL=index.js.map

package/dist/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":";AAAA;;GAEG;;;;;;;;;;;;;;;;AAEH,gDAA8B;AAC9B,mDAAiC"}

package/dist/utils/json-validator.d.ts

@@ -0,0 +1,40 @@
+/**
+ * JSON validation and corruption detection utilities
+ * Detects and attempts to recover from common JSON corruption patterns
+ */
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+    corrupted?: boolean;
+    corruptionType?: 'concatenated' | 'truncated' | 'invalid' | 'empty';
+}
+export interface RecoveryResult {
+    success: boolean;
+    data?: unknown;
+    method?: string;
+    error?: string;
+}
+/**
+ * Check if a string is valid JSON
+ */
+export declare function isValidJson(content: string): boolean;
+/**
+ * Detect corruption in JSON content
+ * Identifies common corruption patterns from race conditions
+ */
+export declare function detectCorruption(content: string): ValidationResult;
+/**
+ * Extract valid JSON from corrupted content
+ * Attempts various recovery strategies
+ */
+export declare function extractValidJson(content: string): RecoveryResult;
+/**
+ * Merge two JSON objects, preferring values from the second
+ * Useful for recovering from partial writes
+ */
+export declare function mergeJsonObjects(obj1: Record<string, unknown>, obj2: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Validate .claude.json specific structure
+ */
+export declare function validateClaudeConfig(content: unknown): ValidationResult;
+//# sourceMappingURL=json-validator.d.ts.map

package/dist/utils/json-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-validator.d.ts","sourceRoot":"","sources":["../../src/utils/json-validator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,cAAc,CAAC,EAAE,cAAc,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;CACrE;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAOpD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,CA0DlE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,CA4DhE;AA8HD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAuBzB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,gBAAgB,CA2BvE"}

package/dist/utils/json-validator.js

@@ -0,0 +1,295 @@
+"use strict";
+/**
+ * JSON validation and corruption detection utilities
+ * Detects and attempts to recover from common JSON corruption patterns
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidJson = isValidJson;
+exports.detectCorruption = detectCorruption;
+exports.extractValidJson = extractValidJson;
+exports.mergeJsonObjects = mergeJsonObjects;
+exports.validateClaudeConfig = validateClaudeConfig;
+/**
+ * Check if a string is valid JSON
+ */
+function isValidJson(content) {
+    try {
+        JSON.parse(content);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Detect corruption in JSON content
+ * Identifies common corruption patterns from race conditions
+ */
+function detectCorruption(content) {
+    if (!content || content.trim() === '') {
+        return {
+            valid: false,
+            corrupted: true,
+            corruptionType: 'empty',
+            error: 'Empty content',
+        };
+    }
+    // Check for concatenated JSON objects (common race condition pattern)
+    // Pattern: }{  indicates two JSON objects were written together
+    if (content.includes('}{')) {
+        return {
+            valid: false,
+            corrupted: true,
+            corruptionType: 'concatenated',
+            error: 'Detected concatenated JSON objects (race condition corruption)',
+        };
+    }
+    // Check for multiple JSON arrays concatenated
+    if (content.includes('][')) {
+        return {
+            valid: false,
+            corrupted: true,
+            corruptionType: 'concatenated',
+            error: 'Detected concatenated JSON arrays',
+        };
+    }
+    // Try to parse
+    try {
+        JSON.parse(content);
+        return { valid: true };
+    }
+    catch (error) {
+        const errorMessage = error.message;
+        // Detect truncated JSON
+        if (errorMessage.includes('Unexpected end of JSON') ||
+            errorMessage.includes('Unexpected end of input')) {
+            return {
+                valid: false,
+                corrupted: true,
+                corruptionType: 'truncated',
+                error: 'JSON appears to be truncated',
+            };
+        }
+        return {
+            valid: false,
+            corrupted: true,
+            corruptionType: 'invalid',
+            error: `Invalid JSON: ${errorMessage}`,
+        };
+    }
+}
+/**
+ * Extract valid JSON from corrupted content
+ * Attempts various recovery strategies
+ */
+function extractValidJson(content) {
+    // Strategy 1: Content is already valid
+    if (isValidJson(content)) {
+        return {
+            success: true,
+            data: JSON.parse(content),
+            method: 'content_already_valid',
+        };
+    }
+    const trimmed = content.trim();
+    // Strategy 2: Handle concatenated JSON objects
+    // Take the first complete JSON object
+    if (trimmed.includes('}{')) {
+        const firstObjectEnd = findMatchingBrace(trimmed, 0);
+        if (firstObjectEnd !== -1) {
+            const firstObject = trimmed.substring(0, firstObjectEnd + 1);
+            if (isValidJson(firstObject)) {
+                return {
+                    success: true,
+                    data: JSON.parse(firstObject),
+                    method: 'extract_first_object',
+                };
+            }
+        }
+        // Alternative: try to take the second object (might be more recent)
+        const secondStart = trimmed.indexOf('}{') + 1;
+        const secondObject = trimmed.substring(secondStart);
+        if (isValidJson(secondObject)) {
+            return {
+                success: true,
+                data: JSON.parse(secondObject),
+                method: 'extract_second_object',
+            };
+        }
+    }
+    // Strategy 3: Handle truncated JSON
+    // Try to complete the JSON by adding missing brackets
+    const result = attemptTruncatedRecovery(trimmed);
+    if (result.success) {
+        return result;
+    }
+    // Strategy 4: Look for the largest valid JSON substring
+    const largestValid = findLargestValidJson(trimmed);
+    if (largestValid) {
+        return {
+            success: true,
+            data: JSON.parse(largestValid),
+            method: 'largest_valid_substring',
+        };
+    }
+    return {
+        success: false,
+        error: 'Could not recover valid JSON from content',
+    };
+}
+/**
+ * Find the index of the matching closing brace for an opening brace
+ */
+function findMatchingBrace(content, startIndex) {
+    let depth = 0;
+    let inString = false;
+    let escapeNext = false;
+    for (let i = startIndex; i < content.length; i++) {
+        const char = content[i];
+        if (escapeNext) {
+            escapeNext = false;
+            continue;
+        }
+        if (char === '\\' && inString) {
+            escapeNext = true;
+            continue;
+        }
+        if (char === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (inString)
+            continue;
+        if (char === '{') {
+            depth++;
+        }
+        else if (char === '}') {
+            depth--;
+            if (depth === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+/**
+ * Attempt to recover truncated JSON
+ */
+function attemptTruncatedRecovery(content) {
+    // Count open brackets and braces
+    let openBraces = 0;
+    let openBrackets = 0;
+    let inString = false;
+    let escapeNext = false;
+    for (const char of content) {
+        if (escapeNext) {
+            escapeNext = false;
+            continue;
+        }
+        if (char === '\\' && inString) {
+            escapeNext = true;
+            continue;
+        }
+        if (char === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (inString)
+            continue;
+        switch (char) {
+            case '{':
+                openBraces++;
+                break;
+            case '}':
+                openBraces--;
+                break;
+            case '[':
+                openBrackets++;
+                break;
+            case ']':
+                openBrackets--;
+                break;
+        }
+    }
+    // If we're inside a string, try to close it
+    if (inString) {
+        content += '"';
+    }
+    // Try to complete with missing brackets/braces
+    const closing = ']'.repeat(Math.max(0, openBrackets)) +
+        '}'.repeat(Math.max(0, openBraces));
+    if (closing) {
+        const completed = content + closing;
+        if (isValidJson(completed)) {
+            return {
+                success: true,
+                data: JSON.parse(completed),
+                method: 'complete_truncated',
+            };
+        }
+    }
+    return { success: false, error: 'Truncated recovery failed' };
+}
+/**
+ * Find the largest valid JSON substring
+ */
+function findLargestValidJson(content) {
+    // Start from the beginning, try to find complete JSON objects
+    for (let end = content.length; end > 1; end--) {
+        const substring = content.substring(0, end);
+        if (isValidJson(substring)) {
+            return substring;
+        }
+    }
+    return null;
+}
+/**
+ * Merge two JSON objects, preferring values from the second
+ * Useful for recovering from partial writes
+ */
+function mergeJsonObjects(obj1, obj2) {
+    const result = { ...obj1 };
+    for (const [key, value] of Object.entries(obj2)) {
+        if (value !== null &&
+            typeof value === 'object' &&
+            !Array.isArray(value) &&
+            result[key] &&
+            typeof result[key] === 'object' &&
+            !Array.isArray(result[key])) {
+            // Recursively merge objects
+            result[key] = mergeJsonObjects(result[key], value);
+        }
+        else if (value !== undefined) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Validate .claude.json specific structure
+ */
+function validateClaudeConfig(content) {
+    if (typeof content !== 'object' || content === null) {
+        return {
+            valid: false,
+            error: 'Config must be an object',
+        };
+    }
+    const config = content;
+    // Check for expected top-level keys (optional validation)
+    const expectedKeys = [
+        'numStartups',
+        'tipsHistory',
+        'userID',
+        'firstStartTime',
+    ];
+    const hasExpectedKeys = expectedKeys.some((key) => key in config);
+    if (!hasExpectedKeys && Object.keys(config).length > 0) {
+        return {
+            valid: false,
+            error: 'Config missing expected Claude configuration keys',
+        };
+    }
+    return { valid: true };
+}
+//# sourceMappingURL=json-validator.js.map