profclaw 0.0.1-beta.3 → 2.0.0

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

@@ -1,85 +0,0 @@
-/**
- * File Locking Utilities
- *
- * Provides safe concurrent access to config and data files
- * using proper-lockfile for cross-process synchronization.
- *
- * Features:
- * - Automatic retry with backoff on lock contention
- * - Stale lock detection and recovery
- * - Clean async/await API
- * - TypeScript-safe with generics
- */
-/**
- * Lock options
- */
-export interface LockOptions {
-    /** Time to wait before declaring lock stale (ms) */
-    stale?: number;
-    /** Retry interval (ms) */
-    retries?: number | {
-        retries: number;
-        factor?: number;
-        minTimeout?: number;
-        maxTimeout?: number;
-    };
-    /** Whether to wait for lock */
-    wait?: boolean;
-    /** Update interval for lock freshness (ms) */
-    update?: number;
-}
-/**
- * Acquire a lock on a file
- * Returns a release function that must be called when done
- */
-export declare function acquireLock(filePath: string, options?: LockOptions): Promise<() => Promise<void>>;
-/**
- * Check if a file is currently locked
- */
-export declare function isLocked(filePath: string): Promise<boolean>;
-/**
- * Execute a function while holding a file lock
- * Automatically releases the lock when done or on error
- */
-export declare function withLock<T>(filePath: string, fn: () => Promise<T>, options?: LockOptions): Promise<T>;
-/**
- * Read a JSON file with locking
- */
-export declare function readJsonWithLock<T>(filePath: string, options?: LockOptions): Promise<T | null>;
-/**
- * Write a JSON file with locking
- */
-export declare function writeJsonWithLock<T>(filePath: string, data: T, options?: LockOptions): Promise<void>;
-/**
- * Update a JSON file atomically with locking
- * Reads current value, applies updater, writes result
- */
-export declare function updateJsonWithLock<T>(filePath: string, updater: (current: T | null) => T, options?: LockOptions): Promise<T>;
-/**
- * Multi-file lock for transactions spanning multiple files
- * All files are locked in a deterministic order to prevent deadlocks
- */
-export declare function withMultiLock<T>(filePaths: string[], fn: () => Promise<T>, options?: LockOptions): Promise<T>;
-/**
- * Lock file path for a given config file
- * Uses a .lock suffix by default
- */
-export declare function getLockFilePath(filePath: string): string;
-/**
- * Clean up stale lock files
- * Use with caution - only for recovery scenarios
- */
-export declare function cleanupStaleLock(filePath: string): Promise<boolean>;
-/**
- * Wrapper for settings file operations
- */
-export declare class LockedConfigFile<T> {
-    private filePath;
-    private options?;
-    constructor(filePath: string, options?: LockOptions | undefined);
-    read(): Promise<T | null>;
-    write(data: T): Promise<void>;
-    update(updater: (current: T | null) => T): Promise<T>;
-    isLocked(): Promise<boolean>;
-}
-//# sourceMappingURL=file-lock.d.ts.map

package/dist/utils/file-lock.js

@@ -1,204 +0,0 @@
-/**
- * File Locking Utilities
- *
- * Provides safe concurrent access to config and data files
- * using proper-lockfile for cross-process synchronization.
- *
- * Features:
- * - Automatic retry with backoff on lock contention
- * - Stale lock detection and recovery
- * - Clean async/await API
- * - TypeScript-safe with generics
- */
-import lockfile from 'proper-lockfile';
-import { existsSync, writeFileSync, mkdirSync } from 'fs';
-import { dirname } from 'path';
-const DEFAULT_LOCK_OPTIONS = {
-    stale: 10000, // 10 seconds
-    retries: {
-        retries: 5,
-        factor: 1.5,
-        minTimeout: 100,
-        maxTimeout: 2000,
-    },
-    update: 5000, // 5 seconds
-};
-/**
- * Ensure file exists before locking
- * (proper-lockfile requires the file to exist)
- */
-function ensureFileExists(filePath) {
-    if (!existsSync(filePath)) {
-        const dir = dirname(filePath);
-        if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
-        }
-        writeFileSync(filePath, '');
-    }
-}
-/**
- * Acquire a lock on a file
- * Returns a release function that must be called when done
- */
-export async function acquireLock(filePath, options) {
-    ensureFileExists(filePath);
-    const opts = { ...DEFAULT_LOCK_OPTIONS, ...options };
-    try {
-        const release = await lockfile.lock(filePath, {
-            stale: opts.stale,
-            retries: opts.retries,
-            update: opts.update,
-        });
-        return release;
-    }
-    catch (error) {
-        if (error.code === 'ELOCKED') {
-            throw new Error(`File is locked by another process: ${filePath}`);
-        }
-        throw error;
-    }
-}
-/**
- * Check if a file is currently locked
- */
-export async function isLocked(filePath) {
-    if (!existsSync(filePath)) {
-        return false;
-    }
-    try {
-        return await lockfile.check(filePath);
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Execute a function while holding a file lock
- * Automatically releases the lock when done or on error
- */
-export async function withLock(filePath, fn, options) {
-    const release = await acquireLock(filePath, options);
-    try {
-        return await fn();
-    }
-    finally {
-        await release();
-    }
-}
-/**
- * Read a JSON file with locking
- */
-export async function readJsonWithLock(filePath, options) {
-    if (!existsSync(filePath)) {
-        return null;
-    }
-    return withLock(filePath, async () => {
-        const { readFileSync } = await import('fs');
-        const content = readFileSync(filePath, 'utf-8');
-        return JSON.parse(content);
-    }, options);
-}
-/**
- * Write a JSON file with locking
- */
-export async function writeJsonWithLock(filePath, data, options) {
-    await withLock(filePath, async () => {
-        const { writeFileSync } = await import('fs');
-        writeFileSync(filePath, JSON.stringify(data, null, 2));
-    }, options);
-}
-/**
- * Update a JSON file atomically with locking
- * Reads current value, applies updater, writes result
- */
-export async function updateJsonWithLock(filePath, updater, options) {
-    return withLock(filePath, async () => {
-        const { readFileSync, writeFileSync } = await import('fs');
-        let current = null;
-        if (existsSync(filePath)) {
-            const content = readFileSync(filePath, 'utf-8');
-            if (content.trim()) {
-                current = JSON.parse(content);
-            }
-        }
-        const updated = updater(current);
-        writeFileSync(filePath, JSON.stringify(updated, null, 2));
-        return updated;
-    }, options);
-}
-/**
- * Multi-file lock for transactions spanning multiple files
- * All files are locked in a deterministic order to prevent deadlocks
- */
-export async function withMultiLock(filePaths, fn, options) {
-    // Sort paths to prevent deadlocks
-    const sortedPaths = [...filePaths].sort();
-    const releases = [];
-    try {
-        // Acquire all locks in order
-        for (const filePath of sortedPaths) {
-            const release = await acquireLock(filePath, options);
-            releases.push(release);
-        }
-        // Execute function
-        return await fn();
-    }
-    finally {
-        // Release all locks in reverse order
-        for (const release of releases.reverse()) {
-            await release().catch(console.error);
-        }
-    }
-}
-/**
- * Lock file path for a given config file
- * Uses a .lock suffix by default
- */
-export function getLockFilePath(filePath) {
-    return `${filePath}.lock`;
-}
-/**
- * Clean up stale lock files
- * Use with caution - only for recovery scenarios
- */
-export async function cleanupStaleLock(filePath) {
-    try {
-        const isStale = await lockfile.check(filePath, { stale: 0 });
-        if (!isStale) {
-            // Not locked or not stale, nothing to do
-            return false;
-        }
-        // Force unlock
-        await lockfile.unlock(filePath, { realpath: false });
-        console.log(`[FileLock] Cleaned up stale lock: ${filePath}`);
-        return true;
-    }
-    catch {
-        // Lock file might not exist
-        return false;
-    }
-}
-/**
- * Wrapper for settings file operations
- */
-export class LockedConfigFile {
-    filePath;
-    options;
-    constructor(filePath, options) {
-        this.filePath = filePath;
-        this.options = options;
-    }
-    async read() {
-        return readJsonWithLock(this.filePath, this.options);
-    }
-    async write(data) {
-        return writeJsonWithLock(this.filePath, data, this.options);
-    }
-    async update(updater) {
-        return updateJsonWithLock(this.filePath, updater, this.options);
-    }
-    async isLocked() {
-        return isLocked(this.filePath);
-    }
-}
-//# sourceMappingURL=file-lock.js.map