profclaw 0.0.1-beta.1

package/dist/memory/memory-watcher.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Memory Watcher
+ *
+ * Automatic memory sync based on OpenClaw's architecture.
+ * Features:
+ * - File watching with chokidar for automatic sync
+ * - Dirty flag to trigger sync before search
+ * - Debounced sync on file changes
+ * - Warm session sync on session start
+ */
+import { type MemoryConfig, type SearchResult } from './memory-service.js';
+export interface MemoryWatcherOptions {
+    /** Base path to watch for memory files */
+    basePath: string;
+    /** Memory configuration */
+    config?: MemoryConfig;
+    /** Callback when sync completes */
+    onSyncComplete?: (result: {
+        added: number;
+        updated: number;
+        removed: number;
+    }) => void;
+    /** Callback when sync starts */
+    onSyncStart?: () => void;
+    /** Callback on errors */
+    onError?: (error: Error) => void;
+}
+export interface MemoryWatcherState {
+    /** Whether files have changed since last sync */
+    dirty: boolean;
+    /** Whether a sync is currently in progress */
+    syncing: boolean;
+    /** Timestamp of last successful sync */
+    lastSyncAt: number | null;
+    /** Number of files being watched */
+    watchedFiles: number;
+    /** Whether the watcher is active */
+    watching: boolean;
+}
+export declare class MemoryWatcher {
+    private watcher;
+    private basePath;
+    private config;
+    private state;
+    private debounceTimer;
+    private onSyncComplete?;
+    private onSyncStart?;
+    private onError?;
+    constructor(options: MemoryWatcherOptions);
+    /**
+     * Get current watcher state
+     */
+    getState(): MemoryWatcherState;
+    /**
+     * Check if files need to be synced
+     */
+    isDirty(): boolean;
+    /**
+     * Mark as dirty (files changed)
+     */
+    markDirty(): void;
+    /**
+     * Start watching memory files
+     */
+    start(): Promise<void>;
+    /**
+     * Stop watching
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle file change events
+     */
+    private handleFileChange;
+    /**
+     * Schedule a debounced sync
+     */
+    private scheduleSync;
+    /**
+     * Perform a sync operation
+     */
+    sync(): Promise<{
+        added: number;
+        updated: number;
+        removed: number;
+    }>;
+    /**
+     * Search with automatic sync if dirty
+     * Implements the onSearch auto-sync pattern from OpenClaw
+     */
+    search(query: string, maxResults?: number): Promise<SearchResult>;
+    /**
+     * Warm session - sync on session start
+     * Call this when a new chat session starts
+     */
+    warmSession(): Promise<void>;
+}
+/**
+ * Get or create the global memory watcher
+ */
+export declare function getMemoryWatcher(): MemoryWatcher | null;
+/**
+ * Initialize the global memory watcher
+ */
+export declare function initMemoryWatcher(options: MemoryWatcherOptions): Promise<MemoryWatcher>;
+/**
+ * Stop the global memory watcher
+ */
+export declare function stopMemoryWatcher(): Promise<void>;
+declare const _default: {
+    MemoryWatcher: typeof MemoryWatcher;
+    getMemoryWatcher: typeof getMemoryWatcher;
+    initMemoryWatcher: typeof initMemoryWatcher;
+    stopMemoryWatcher: typeof stopMemoryWatcher;
+};
+export default _default;
+//# sourceMappingURL=memory-watcher.d.ts.map

package/dist/memory/memory-watcher.js

@@ -0,0 +1,239 @@
+/**
+ * Memory Watcher
+ *
+ * Automatic memory sync based on OpenClaw's architecture.
+ * Features:
+ * - File watching with chokidar for automatic sync
+ * - Dirty flag to trigger sync before search
+ * - Debounced sync on file changes
+ * - Warm session sync on session start
+ */
+import { watch } from 'chokidar';
+import { join, basename, extname } from 'node:path';
+import { syncMemoryFiles, searchMemory, DEFAULT_MEMORY_CONFIG } from './memory-service.js';
+import { logger } from '../utils/logger.js';
+// Memory Watcher Class
+export class MemoryWatcher {
+    watcher = null;
+    basePath;
+    config;
+    state = {
+        dirty: true, // Start dirty to ensure initial sync
+        syncing: false,
+        lastSyncAt: null,
+        watchedFiles: 0,
+        watching: false,
+    };
+    debounceTimer = null;
+    onSyncComplete;
+    onSyncStart;
+    onError;
+    constructor(options) {
+        this.basePath = options.basePath;
+        this.config = options.config || DEFAULT_MEMORY_CONFIG;
+        this.onSyncComplete = options.onSyncComplete;
+        this.onSyncStart = options.onSyncStart;
+        this.onError = options.onError;
+    }
+    /**
+     * Get current watcher state
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Check if files need to be synced
+     */
+    isDirty() {
+        return this.state.dirty;
+    }
+    /**
+     * Mark as dirty (files changed)
+     */
+    markDirty() {
+        this.state.dirty = true;
+    }
+    /**
+     * Start watching memory files
+     */
+    async start() {
+        if (this.watcher) {
+            logger.warn('[MemoryWatcher] Already watching');
+            return;
+        }
+        // Paths to watch
+        const memoryFile = join(this.basePath, this.config.paths.memoryFile);
+        const memoryDir = join(this.basePath, this.config.paths.memoryDir);
+        const altMemoryFile = join(this.basePath, 'memory.md'); // Also watch lowercase
+        // Build glob patterns
+        const patterns = [
+            memoryFile,
+            altMemoryFile,
+            join(memoryDir, '*.md'),
+            join(memoryDir, '*.txt'),
+            join(memoryDir, '*.markdown'),
+        ];
+        logger.info(`[MemoryWatcher] Starting watch on ${this.basePath}`);
+        logger.debug(`[MemoryWatcher] Watching patterns: ${patterns.join(', ')}`);
+        this.watcher = watch(patterns, {
+            ignoreInitial: true, // Don't trigger on initial scan
+            persistent: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 500,
+                pollInterval: 100,
+            },
+        });
+        this.watcher.on('add', (path) => this.handleFileChange('add', path));
+        this.watcher.on('change', (path) => this.handleFileChange('change', path));
+        this.watcher.on('unlink', (path) => this.handleFileChange('unlink', path));
+        this.watcher.on('ready', () => {
+            const watched = this.watcher?.getWatched() || {};
+            this.state.watchedFiles = Object.values(watched).reduce((acc, files) => acc + files.length, 0);
+            this.state.watching = true;
+            logger.info(`[MemoryWatcher] Ready, watching ${this.state.watchedFiles} files`);
+        });
+        this.watcher.on('error', (err) => {
+            const error = err instanceof Error ? err : new Error(String(err));
+            logger.error('[MemoryWatcher] Error:', error);
+            this.onError?.(error);
+        });
+        // Perform initial sync if configured
+        if (this.config.sync.onSessionStart) {
+            await this.sync();
+        }
+    }
+    /**
+     * Stop watching
+     */
+    async stop() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
+            this.state.watching = false;
+            logger.info('[MemoryWatcher] Stopped');
+        }
+    }
+    /**
+     * Handle file change events
+     */
+    handleFileChange(event, path) {
+        const filename = basename(path);
+        const ext = extname(path).toLowerCase();
+        // Only process memory files
+        if (!['.md', '.txt', '.markdown'].includes(ext)) {
+            return;
+        }
+        logger.debug(`[MemoryWatcher] File ${event}: ${filename}`);
+        this.state.dirty = true;
+        // Schedule debounced sync if watch sync is enabled
+        if (this.config.sync.watch) {
+            this.scheduleSync();
+        }
+    }
+    /**
+     * Schedule a debounced sync
+     */
+    scheduleSync() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(() => {
+            this.sync().catch((error) => {
+                logger.error('[MemoryWatcher] Scheduled sync failed:', error);
+                this.onError?.(error);
+            });
+        }, this.config.sync.watchDebounceMs);
+    }
+    /**
+     * Perform a sync operation
+     */
+    async sync() {
+        if (this.state.syncing) {
+            logger.debug('[MemoryWatcher] Sync already in progress');
+            return { added: 0, updated: 0, removed: 0 };
+        }
+        this.state.syncing = true;
+        this.onSyncStart?.();
+        try {
+            logger.info('[MemoryWatcher] Syncing memory files...');
+            const result = await syncMemoryFiles(this.basePath, this.config);
+            this.state.dirty = false;
+            this.state.lastSyncAt = Date.now();
+            logger.info(`[MemoryWatcher] Sync complete: ${result.added} added, ${result.updated} updated, ${result.removed} removed`);
+            this.onSyncComplete?.(result);
+            return result;
+        }
+        catch (error) {
+            logger.error('[MemoryWatcher] Sync failed:', error);
+            this.onError?.(error);
+            throw error;
+        }
+        finally {
+            this.state.syncing = false;
+        }
+    }
+    /**
+     * Search with automatic sync if dirty
+     * Implements the onSearch auto-sync pattern from OpenClaw
+     */
+    async search(query, maxResults) {
+        // Auto-sync before search if dirty and configured
+        if (this.config.sync.onSearch && this.state.dirty && !this.state.syncing) {
+            logger.debug('[MemoryWatcher] Auto-syncing before search');
+            await this.sync();
+        }
+        const searchConfig = maxResults
+            ? { ...this.config, query: { ...this.config.query, maxResults } }
+            : this.config;
+        return searchMemory(query, searchConfig);
+    }
+    /**
+     * Warm session - sync on session start
+     * Call this when a new chat session starts
+     */
+    async warmSession() {
+        if (this.config.sync.onSessionStart) {
+            logger.info('[MemoryWatcher] Warming session with memory sync');
+            await this.sync();
+        }
+    }
+}
+// Singleton Instance
+let globalWatcher = null;
+/**
+ * Get or create the global memory watcher
+ */
+export function getMemoryWatcher() {
+    return globalWatcher;
+}
+/**
+ * Initialize the global memory watcher
+ */
+export async function initMemoryWatcher(options) {
+    if (globalWatcher) {
+        await globalWatcher.stop();
+    }
+    globalWatcher = new MemoryWatcher(options);
+    await globalWatcher.start();
+    return globalWatcher;
+}
+/**
+ * Stop the global memory watcher
+ */
+export async function stopMemoryWatcher() {
+    if (globalWatcher) {
+        await globalWatcher.stop();
+        globalWatcher = null;
+    }
+}
+export default {
+    MemoryWatcher,
+    getMemoryWatcher,
+    initMemoryWatcher,
+    stopMemoryWatcher,
+};
+//# sourceMappingURL=memory-watcher.js.map

package/dist/middleware/logging.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Request/Response Logging Middleware for Hono
+ *
+ * Logs all HTTP requests and responses with:
+ * - Correlation IDs for request tracing
+ * - Request details (method, path, headers)
+ * - Response details (status, duration)
+ * - Error tracking
+ */
+import type { Context, Next } from 'hono';
+/**
+ * Request logging middleware
+ */
+export declare function requestLogger(c: Context, next: Next): Promise<void>;
+/**
+ * Request body logging middleware (use with caution)
+ * Only logs for non-GET requests and respects content type
+ */
+export declare function requestBodyLogger(c: Context, next: Next): Promise<void>;
+/**
+ * Response time header middleware
+ */
+export declare function responseTimeHeader(c: Context, next: Next): Promise<void>;
+/**
+ * Error logging middleware
+ * Should be added early in middleware chain
+ */
+export declare function errorLogger(c: Context, next: Next): Promise<Response | void>;
+/**
+ * Slow request logger
+ * Logs warning for requests exceeding threshold
+ */
+export declare function slowRequestLogger(thresholdMs?: number): (c: Context, next: Next) => Promise<void>;
+//# sourceMappingURL=logging.d.ts.map

package/dist/middleware/logging.js

@@ -0,0 +1,184 @@
+/**
+ * Request/Response Logging Middleware for Hono
+ *
+ * Logs all HTTP requests and responses with:
+ * - Correlation IDs for request tracing
+ * - Request details (method, path, headers)
+ * - Response details (status, duration)
+ * - Error tracking
+ */
+import { logger, generateCorrelationId, withCorrelation } from '../utils/logger.js';
+/**
+ * Request logging middleware
+ */
+export async function requestLogger(c, next) {
+    // Generate or extract correlation ID
+    const correlationId = c.req.header('X-Correlation-ID') ||
+        c.req.header('X-Request-ID') ||
+        generateCorrelationId();
+    // Add correlation ID to response headers
+    c.header('X-Correlation-ID', correlationId);
+    const startTime = Date.now();
+    const method = c.req.method;
+    const path = c.req.path;
+    const userAgent = c.req.header('User-Agent');
+    const ip = c.req.header('X-Forwarded-For') || c.req.header('X-Real-IP') || 'unknown';
+    // Create request context
+    const requestContext = {
+        correlationId,
+        method,
+        path,
+        ip,
+        userAgent,
+    };
+    // Log incoming request
+    logger.info('→ Incoming request', requestContext);
+    // Run the request handler within correlation context
+    try {
+        await withCorrelation(correlationId, async () => {
+            await next();
+        });
+        // Log successful response
+        const duration = Date.now() - startTime;
+        const status = c.res.status;
+        logger.info('← Response sent', {
+            ...requestContext,
+            status,
+            duration,
+        });
+    }
+    catch (error) {
+        // Log error response
+        const duration = Date.now() - startTime;
+        logger.error('← Error response', error, {
+            ...requestContext,
+            duration,
+        });
+        // Re-throw to let error handler deal with it
+        throw error;
+    }
+}
+/**
+ * Request body logging middleware (use with caution)
+ * Only logs for non-GET requests and respects content type
+ */
+export async function requestBodyLogger(c, next) {
+    const correlationId = c.req.header('X-Correlation-ID') || generateCorrelationId();
+    // Only log non-GET requests
+    if (c.req.method !== 'GET' && c.req.method !== 'HEAD') {
+        const contentType = c.req.header('Content-Type') || '';
+        // Only log JSON payloads
+        if (contentType.includes('application/json')) {
+            try {
+                const body = await c.req.json();
+                logger.debug('Request body', {
+                    correlationId,
+                    body: sanitizeBody(body),
+                });
+                // Re-create request with body (since we consumed it)
+                c.req.raw = new Request(c.req.url, {
+                    method: c.req.method,
+                    headers: c.req.raw.headers,
+                    body: JSON.stringify(body),
+                });
+            }
+            catch {
+                logger.warn('Failed to parse request body as JSON', {
+                    correlationId,
+                });
+            }
+        }
+    }
+    await next();
+}
+/**
+ * Sanitize request/response bodies
+ * Removes sensitive data like passwords, tokens, etc.
+ */
+function sanitizeBody(body) {
+    if (!body || typeof body !== 'object') {
+        return body;
+    }
+    const sensitiveFields = [
+        'password',
+        'token',
+        'secret',
+        'apiKey',
+        'api_key',
+        'accessToken',
+        'access_token',
+        'refreshToken',
+        'refresh_token',
+        'privateKey',
+        'private_key',
+    ];
+    if (Array.isArray(body)) {
+        return body.map((item) => sanitizeBody(item));
+    }
+    const record = body;
+    const sanitized = { ...record };
+    for (const key of Object.keys(sanitized)) {
+        const lowerKey = key.toLowerCase();
+        if (sensitiveFields.some((field) => lowerKey.includes(field.toLowerCase()))) {
+            sanitized[key] = '[REDACTED]';
+        }
+        else if (typeof sanitized[key] === 'object' && sanitized[key] !== null) {
+            sanitized[key] = sanitizeBody(sanitized[key]);
+        }
+    }
+    return sanitized;
+}
+/**
+ * Response time header middleware
+ */
+export async function responseTimeHeader(c, next) {
+    const startTime = Date.now();
+    await next();
+    const duration = Date.now() - startTime;
+    c.header('X-Response-Time', `${duration}ms`);
+}
+/**
+ * Error logging middleware
+ * Should be added early in middleware chain
+ */
+export async function errorLogger(c, next) {
+    try {
+        await next();
+    }
+    catch (error) {
+        const correlationId = c.req.header('X-Correlation-ID') || 'unknown';
+        logger.error('Unhandled error in request', error, {
+            correlationId,
+            method: c.req.method,
+            path: c.req.path,
+        });
+        // Return error response
+        return c.json({
+            error: 'Internal Server Error',
+            correlationId,
+            message: error instanceof Error ? error.message : 'Unknown error',
+        }, 500);
+    }
+}
+/**
+ * Slow request logger
+ * Logs warning for requests exceeding threshold
+ */
+export function slowRequestLogger(thresholdMs = 1000) {
+    return async function (c, next) {
+        const startTime = Date.now();
+        const correlationId = c.req.header('X-Correlation-ID') || 'unknown';
+        await next();
+        const duration = Date.now() - startTime;
+        if (duration > thresholdMs) {
+            logger.warn('Slow request detected', {
+                correlationId,
+                method: c.req.method,
+                path: c.req.path,
+                duration,
+                threshold: thresholdMs,
+            });
+        }
+    };
+}
+//# sourceMappingURL=logging.js.map

package/dist/middleware/rate-limit.d.ts

@@ -0,0 +1,29 @@
+import { type Context, type Next } from 'hono';
+interface RateLimitConfig {
+    /** Window duration in milliseconds */
+    windowMs: number;
+    /** Max requests per window per IP */
+    maxRequests: number;
+    /** Alias for maxRequests (backward compat) */
+    max?: number;
+    /** Custom error message */
+    message?: string;
+    /** Max tracked IPs before eviction (prevents memory leak) */
+    maxClients?: number;
+    /** Cleanup interval in milliseconds */
+    cleanupIntervalMs?: number;
+}
+/**
+ * Sliding-window rate limiter middleware for Hono.
+ *
+ * Uses a sliding window (not fixed window) for accurate rate limiting.
+ * Returns proper 429 with Retry-After and X-RateLimit-* headers.
+ * Includes periodic cleanup and max client eviction to prevent memory leaks.
+ */
+export declare function rateLimit(config?: Partial<RateLimitConfig>): RateLimitMiddleware;
+export interface RateLimitMiddleware {
+    (c: Context, next: Next): Promise<Response | void>;
+    destroy: () => void;
+}
+export {};
+//# sourceMappingURL=rate-limit.d.ts.map

package/dist/middleware/rate-limit.js

@@ -0,0 +1,91 @@
+const DEFAULT_CONFIG = {
+    windowMs: 60 * 1000,
+    maxRequests: 100,
+    message: 'Too many requests, please try again later.',
+    maxClients: 10000,
+    cleanupIntervalMs: 60000,
+};
+/**
+ * Sliding-window rate limiter middleware for Hono.
+ *
+ * Uses a sliding window (not fixed window) for accurate rate limiting.
+ * Returns proper 429 with Retry-After and X-RateLimit-* headers.
+ * Includes periodic cleanup and max client eviction to prevent memory leaks.
+ */
+export function rateLimit(config = {}) {
+    // Support `max` as alias for `maxRequests` (backward compat)
+    if (config.max !== undefined && config.maxRequests === undefined) {
+        config.maxRequests = config.max;
+    }
+    const opts = { ...DEFAULT_CONFIG, ...config };
+    const clients = new Map();
+    let destroyed = false;
+    // Periodic cleanup of expired entries
+    const cleanupTimer = setInterval(() => {
+        const cutoff = Date.now() - opts.windowMs;
+        for (const [ip, entry] of clients) {
+            entry.timestamps = entry.timestamps.filter(t => t > cutoff);
+            if (entry.timestamps.length === 0) {
+                clients.delete(ip);
+            }
+        }
+        // Evict oldest clients if exceeding max to bound memory
+        if (clients.size > opts.maxClients) {
+            const sorted = [...clients.entries()]
+                .sort((a, b) => {
+                const latestA = a[1].timestamps.length > 0 ? Math.max(...a[1].timestamps) : 0;
+                const latestB = b[1].timestamps.length > 0 ? Math.max(...b[1].timestamps) : 0;
+                return latestA - latestB;
+            });
+            const toRemove = sorted.slice(0, sorted.length - opts.maxClients);
+            for (const [key] of toRemove) {
+                clients.delete(key);
+            }
+        }
+    }, opts.cleanupIntervalMs);
+    const middleware = async (c, next) => {
+        const ip = c.req.header('x-forwarded-for')?.split(',')[0]?.trim()
+            || c.req.header('x-real-ip')
+            || 'anonymous';
+        const now = Date.now();
+        const cutoff = now - opts.windowMs;
+        let entry = clients.get(ip);
+        if (!entry) {
+            entry = { timestamps: [] };
+            clients.set(ip, entry);
+        }
+        // Remove expired timestamps (sliding window)
+        entry.timestamps = entry.timestamps.filter(t => t > cutoff);
+        // Calculate rate limit headers
+        const currentCount = entry.timestamps.length;
+        const remaining = Math.max(0, opts.maxRequests - currentCount);
+        const resetAt = entry.timestamps.length > 0
+            ? entry.timestamps[0] + opts.windowMs
+            : now + opts.windowMs;
+        c.header('X-RateLimit-Limit', opts.maxRequests.toString());
+        c.header('X-RateLimit-Remaining', remaining.toString());
+        c.header('X-RateLimit-Reset', Math.ceil(resetAt / 1000).toString());
+        if (currentCount >= opts.maxRequests) {
+            const retryAfter = Math.ceil((resetAt - now) / 1000);
+            c.header('Retry-After', Math.max(1, retryAfter).toString());
+            return c.json({
+                error: 'Rate limit exceeded',
+                message: opts.message,
+                retryAfter: Math.max(1, retryAfter),
+            }, 429);
+        }
+        // Record this request
+        entry.timestamps.push(now);
+        await next();
+    };
+    // Attach destroy method for graceful shutdown
+    middleware.destroy = () => {
+        if (!destroyed) {
+            clearInterval(cleanupTimer);
+            clients.clear();
+            destroyed = true;
+        }
+    };
+    return middleware;
+}
+//# sourceMappingURL=rate-limit.js.map