watchfix 0.1.0

package/dist/fixer/verifier.d.ts

@@ -0,0 +1,44 @@
+import type { Config } from '../config/schema.js';
+import { Logger } from '../utils/logger.js';
+type VerificationCommandResult = {
+    command: string;
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    timedOut: boolean;
+};
+type VerificationHealthCheckResult = {
+    url: string;
+    success: boolean;
+    status?: number;
+    error?: string;
+};
+type VerificationFailure = {
+    type: 'command';
+    command: string;
+    message: string;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    timedOut: boolean;
+} | {
+    type: 'health_check';
+    url: string;
+    message: string;
+    status?: number;
+    error?: string;
+};
+export type VerificationResult = {
+    success: boolean;
+    commandResults: VerificationCommandResult[];
+    healthCheckResults: VerificationHealthCheckResult[];
+    failure?: VerificationFailure;
+};
+type RunVerificationOptions = {
+    logger?: Logger;
+    terminalEnabled?: boolean;
+    sleep?: (ms: number) => Promise<void>;
+};
+export declare function runVerification(config: Config, options?: RunVerificationOptions): Promise<VerificationResult>;
+export {};

package/dist/fixer/verifier.js

@@ -0,0 +1,133 @@
+import { parseDuration, formatDuration } from '../utils/duration.js';
+import { checkHealth } from '../utils/http.js';
+import { Logger } from '../utils/logger.js';
+import { spawnWithTimeout } from '../utils/process.js';
+const defaultSleep = async (ms) => await new Promise((resolve) => setTimeout(resolve, ms));
+const formatCommandFailureMessage = (command, result, timeoutMs) => {
+    if (result.timedOut) {
+        return `Command timed out after ${formatDuration(timeoutMs)}: ${command}`;
+    }
+    if (result.exitCode !== 0) {
+        return `Command exited with code ${result.exitCode}: ${command}`;
+    }
+    return `Command failed: ${command}`;
+};
+const logCommandOutput = (logger, command, result, level = 'debug') => {
+    const stdout = result.stdout.trim();
+    const stderr = result.stderr.trim();
+    const log = (message) => {
+        if (level === 'info') {
+            logger.info(message);
+        }
+        else if (level === 'warn') {
+            logger.warn(message);
+        }
+        else {
+            logger.debug(message);
+        }
+    };
+    if (stdout) {
+        log(`Command stdout (${command}):\n${stdout}`);
+    }
+    if (stderr) {
+        logger.warn(`Command stderr (${command}):\n${stderr}`);
+    }
+};
+const logHealthCheckFailure = (logger, url, result) => {
+    if (result.error) {
+        const message = `Health check failed for ${url}: ${result.error}`;
+        logger.error(message);
+        return message;
+    }
+    if (typeof result.status === 'number') {
+        const message = `Health check failed for ${url}: status ${result.status}`;
+        logger.error(message);
+        return message;
+    }
+    const message = `Health check failed for ${url}`;
+    logger.error(message);
+    return message;
+};
+export async function runVerification(config, options) {
+    const logger = options?.logger ??
+        new Logger({
+            rootDir: config.project.root,
+            terminalEnabled: options?.terminalEnabled ?? true,
+        });
+    const sleep = options?.sleep ?? defaultSleep;
+    const verification = config.verification;
+    const waitMs = parseDuration(verification.wait_after_fix);
+    if (waitMs > 0) {
+        logger.info(`Waiting ${formatDuration(waitMs)} before verification`);
+        await sleep(waitMs);
+    }
+    const commandResults = [];
+    const healthCheckResults = [];
+    const commands = verification.test_commands ?? [];
+    if (commands.length > 0) {
+        const timeoutMs = parseDuration(verification.test_command_timeout);
+        for (const command of commands) {
+            logger.info(`Running verification command: ${command}`);
+            const result = await spawnWithTimeout(command, [], { cwd: config.project.root, shell: true }, timeoutMs);
+            const commandResult = {
+                command,
+                success: result.success,
+                stdout: result.stdout,
+                stderr: result.stderr,
+                exitCode: result.exitCode,
+                timedOut: result.timedOut,
+            };
+            commandResults.push(commandResult);
+            if (!result.success) {
+                const message = formatCommandFailureMessage(command, result, timeoutMs);
+                logger.error(message);
+                logCommandOutput(logger, command, result, 'info');
+                return {
+                    success: false,
+                    commandResults,
+                    healthCheckResults,
+                    failure: {
+                        type: 'command',
+                        command,
+                        message,
+                        stdout: result.stdout,
+                        stderr: result.stderr,
+                        exitCode: result.exitCode,
+                        timedOut: result.timedOut,
+                    },
+                };
+            }
+            logCommandOutput(logger, command, result);
+        }
+    }
+    const healthChecks = verification.health_checks ?? [];
+    if (healthChecks.length > 0) {
+        const timeoutMs = parseDuration(verification.health_check_timeout);
+        for (const url of healthChecks) {
+            logger.info(`Running health check: ${url}`);
+            const result = await checkHealth(url, timeoutMs);
+            healthCheckResults.push({ url, ...result });
+            if (!result.success) {
+                const message = logHealthCheckFailure(logger, url, result);
+                return {
+                    success: false,
+                    commandResults,
+                    healthCheckResults,
+                    failure: {
+                        type: 'health_check',
+                        url,
+                        message,
+                        status: result.status,
+                        error: result.error,
+                    },
+                };
+            }
+        }
+    }
+    logger.info('Verification succeeded');
+    return {
+        success: true,
+        commandResults,
+        healthCheckResults,
+    };
+}

package/dist/utils/daemon.d.ts

@@ -0,0 +1,22 @@
+import type { Database } from '../db/index.js';
+import type { Logger } from './logger.js';
+export type CurrentFix = {
+    promise: Promise<unknown>;
+    abort: () => void;
+};
+export type DaemonOrchestrator = {
+    stopWatchers?: () => void | Promise<void>;
+    stop?: () => void | Promise<void>;
+    getCurrentFix?: () => CurrentFix | null;
+    releaseAllLocks?: () => Promise<void>;
+};
+type SetupSignalOptions = {
+    logger?: Logger;
+    db?: Database;
+    clearWatcherState?: () => void;
+    onShutdown?: () => void | Promise<void>;
+};
+export declare function daemonize(): number;
+export declare function setupSignalHandlers(orchestrator: DaemonOrchestrator, options?: SetupSignalOptions): void;
+export declare function recoverStaleErrors(db: Database, logger?: Logger): void;
+export {};

package/dist/utils/daemon.js

@@ -0,0 +1,143 @@
+import { spawn } from 'node:child_process';
+import { logActivity } from '../db/queries.js';
+import { LOCK_TIMEOUT_MS } from '../fixer/lock.js';
+import { EXIT_CODES, InternalError, UserError } from './errors.js';
+const SHUTDOWN_TIMEOUT_MS = 30_000;
+function getForwardedArgs() {
+    const argv = process.argv.slice(2);
+    const filtered = argv.filter((arg) => arg !== '--daemon' && arg !== '--daemon-child');
+    const watchIndex = filtered.indexOf('watch');
+    if (watchIndex >= 0) {
+        filtered.splice(watchIndex + 1, 0, '--daemon-child');
+        return filtered;
+    }
+    return ['watch', '--daemon-child', ...filtered];
+}
+export function daemonize() {
+    if (process.platform === 'win32') {
+        throw new UserError('Daemon mode is not supported on Windows.\n' +
+            'Use foreground mode: watchfix watch --autonomous\n' +
+            'Or use a process manager like PM2: pm2 start watchfix -- watch --autonomous');
+    }
+    const scriptPath = process.argv[1];
+    if (!scriptPath) {
+        throw new InternalError('Unable to resolve watchfix entrypoint.');
+    }
+    const args = getForwardedArgs();
+    const child = spawn(process.execPath, [scriptPath, ...args], {
+        detached: true,
+        stdio: ['ignore', 'ignore', 'ignore'],
+        cwd: process.cwd(),
+        env: { ...process.env, WATCHFIX_DAEMON: '1' },
+    });
+    child.unref();
+    if (!child.pid) {
+        throw new InternalError('Failed to spawn daemon process.');
+    }
+    return child.pid;
+}
+export function setupSignalHandlers(orchestrator, options = {}) {
+    let shuttingDown = false;
+    const logger = options.logger;
+    const logInfo = (message) => {
+        if (logger) {
+            logger.info(message);
+            return;
+        }
+        process.stderr.write(`${message}\n`);
+    };
+    const logWarn = (message) => {
+        if (logger) {
+            logger.warn(message);
+            return;
+        }
+        process.stderr.write(`${message}\n`);
+    };
+    const shutdown = async (signal) => {
+        if (shuttingDown) {
+            return;
+        }
+        shuttingDown = true;
+        logInfo(`Received ${signal}, shutting down...`);
+        const stopResult = orchestrator.stopWatchers?.() ?? orchestrator.stop?.();
+        if (stopResult instanceof Promise) {
+            await stopResult;
+        }
+        const currentFix = orchestrator.getCurrentFix?.() ?? null;
+        if (currentFix) {
+            logInfo('Waiting for current fix to complete...');
+            let timeoutId = null;
+            try {
+                const timeoutPromise = new Promise((resolve) => {
+                    timeoutId = setTimeout(() => {
+                        logWarn('Fix did not complete in time, aborting');
+                        currentFix.abort();
+                        resolve('timeout');
+                    }, SHUTDOWN_TIMEOUT_MS);
+                });
+                const result = await Promise.race([
+                    currentFix.promise.then(() => 'completed'),
+                    timeoutPromise,
+                ]);
+                if (result === 'timeout') {
+                    logWarn('Continuing shutdown without waiting for fix completion');
+                }
+            }
+            catch (error) {
+                logWarn(`Current fix ended with error during shutdown: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            finally {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+            }
+        }
+        if (orchestrator.releaseAllLocks) {
+            await orchestrator.releaseAllLocks();
+        }
+        if (options.clearWatcherState) {
+            options.clearWatcherState();
+        }
+        if (options.db) {
+            logActivity(options.db, 'watcher_stop', undefined, JSON.stringify({ signal, graceful: true }));
+            options.db.close();
+        }
+        if (options.onShutdown) {
+            await options.onShutdown();
+        }
+        logInfo('Shutdown complete');
+        const exitCode = signal === 'SIGINT' ? EXIT_CODES.INTERRUPTED : EXIT_CODES.SUCCESS;
+        process.exit(exitCode);
+    };
+    process.on('SIGTERM', () => {
+        void shutdown('SIGTERM');
+    });
+    process.on('SIGINT', () => {
+        void shutdown('SIGINT');
+    });
+    if (process.platform !== 'win32') {
+        process.on('SIGHUP', () => {
+            void shutdown('SIGHUP');
+        });
+    }
+}
+export function recoverStaleErrors(db, logger) {
+    const staleThreshold = new Date(Date.now() - LOCK_TIMEOUT_MS).toISOString();
+    const now = new Date().toISOString();
+    const result1 = db.run(`UPDATE errors
+     SET status = 'pending', locked_by = NULL, locked_at = NULL, updated_at = ?
+     WHERE status IN ('analyzing', 'fixing')
+       AND locked_at < ?`, [now, staleThreshold]);
+    const result2 = db.run(`UPDATE errors
+     SET locked_by = NULL, locked_at = NULL, updated_at = ?
+     WHERE status = 'suggested'
+       AND locked_by IS NOT NULL
+       AND locked_at < ?`, [now, staleThreshold]);
+    const total = result1.changes + result2.changes;
+    if (total > 0) {
+        if (logger) {
+            logger.warn(`Recovered ${result1.changes} stale error(s), cleared ${result2.changes} stale lock(s)`);
+        }
+        logActivity(db, 'stale_recovery', undefined, JSON.stringify({ reset: result1.changes, unlocked: result2.changes }));
+    }
+}

package/dist/utils/duration.d.ts

@@ -0,0 +1,2 @@
+export declare function parseDuration(input: string): number;
+export declare function formatDuration(ms: number): string;

package/dist/utils/duration.js

@@ -0,0 +1,31 @@
+import { UserError } from './errors.js';
+const DURATION_REGEX = /^(\d+(?:\.\d+)?)([smh])$/;
+const SECOND_MS = 1000;
+const MINUTE_MS = 60 * SECOND_MS;
+const HOUR_MS = 60 * MINUTE_MS;
+export function parseDuration(input) {
+    const trimmed = input.trim();
+    const match = DURATION_REGEX.exec(trimmed);
+    if (!match) {
+        throw new UserError(`Invalid duration: ${input}`);
+    }
+    const value = Number(match[1]);
+    if (!Number.isFinite(value) || value < 0) {
+        throw new UserError(`Invalid duration: ${input}`);
+    }
+    const unit = match[2];
+    const multiplier = unit === 'h' ? HOUR_MS : unit === 'm' ? MINUTE_MS : SECOND_MS;
+    return value * multiplier;
+}
+export function formatDuration(ms) {
+    if (ms % HOUR_MS === 0) {
+        return `${ms / HOUR_MS}h`;
+    }
+    if (ms % MINUTE_MS === 0) {
+        return `${ms / MINUTE_MS}m`;
+    }
+    if (ms % SECOND_MS === 0) {
+        return `${ms / SECOND_MS}s`;
+    }
+    return `${ms}ms`;
+}

package/dist/utils/errors.d.ts

@@ -0,0 +1,17 @@
+export declare class UserError extends Error {
+    constructor(message: string);
+}
+export declare class InternalError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export type ErrorStatus = 'pending' | 'analyzing' | 'suggested' | 'fixing' | 'fixed' | 'failed' | 'ignored';
+export declare const EXIT_CODES: {
+    readonly SUCCESS: 0;
+    readonly GENERAL_ERROR: 1;
+    readonly WATCHER_CONFLICT: 2;
+    readonly NOT_ACTIONABLE: 3;
+    readonly SCHEMA_MISMATCH: 4;
+    readonly INTERRUPTED: 130;
+};

package/dist/utils/errors.js

@@ -0,0 +1,20 @@
+export class UserError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'UserError';
+    }
+}
+export class InternalError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'InternalError';
+    }
+}
+export const EXIT_CODES = {
+    SUCCESS: 0,
+    GENERAL_ERROR: 1,
+    WATCHER_CONFLICT: 2,
+    NOT_ACTIONABLE: 3,
+    SCHEMA_MISMATCH: 4,
+    INTERRUPTED: 130,
+};

package/dist/utils/hash.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeMessage(message: string): string;
+export declare function computeErrorHash(source: string, errorType: string, message: string): string;

package/dist/utils/hash.js

@@ -0,0 +1,18 @@
+import { createHash } from 'crypto';
+const ISO_TIMESTAMP_REGEX = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?/g;
+const UUID_REGEX = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi;
+const HEX_ADDRESS_REGEX = /0x[0-9a-f]+/gi;
+const WHITESPACE_REGEX = /\s+/g;
+export function normalizeMessage(message) {
+    return message
+        .replace(ISO_TIMESTAMP_REGEX, '')
+        .replace(UUID_REGEX, '')
+        .replace(HEX_ADDRESS_REGEX, '')
+        .replace(WHITESPACE_REGEX, ' ')
+        .trim();
+}
+export function computeErrorHash(source, errorType, message) {
+    const normalizedMessage = normalizeMessage(message);
+    const input = `${source}${errorType}${normalizedMessage}`;
+    return createHash('sha256').update(input).digest('hex');
+}

package/dist/utils/http.d.ts

@@ -0,0 +1,6 @@
+export interface HealthCheckResult {
+    success: boolean;
+    status?: number;
+    error?: string;
+}
+export declare function checkHealth(url: string, timeout?: number): Promise<HealthCheckResult>;

package/dist/utils/http.js

@@ -0,0 +1,61 @@
+const MAX_REDIRECTS = 5;
+const USER_AGENT = 'watchfix/1.0';
+const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
+function isRedirect(status) {
+    return REDIRECT_STATUSES.has(status);
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === 'AbortError';
+}
+function resolveErrorMessage(error) {
+    if (error && typeof error === 'object') {
+        const err = error;
+        return (err.cause?.code ??
+            err.cause?.message ??
+            err.code ??
+            err.message ??
+            'Network error');
+    }
+    return 'Network error';
+}
+export async function checkHealth(url, timeout = 10_000) {
+    let currentUrl = url;
+    let redirects = 0;
+    while (redirects <= MAX_REDIRECTS) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout);
+        try {
+            const response = await fetch(currentUrl, {
+                method: 'GET',
+                headers: { 'User-Agent': USER_AGENT },
+                redirect: 'manual',
+                signal: controller.signal,
+            });
+            clearTimeout(timer);
+            if (isRedirect(response.status)) {
+                if (redirects >= MAX_REDIRECTS) {
+                    return { success: false, error: 'Too many redirects' };
+                }
+                const location = response.headers.get('location');
+                if (!location) {
+                    return { success: false, status: response.status };
+                }
+                redirects += 1;
+                currentUrl = new URL(location, currentUrl).toString();
+                continue;
+            }
+            if (response.status >= 200 && response.status <= 299) {
+                return { success: true, status: response.status };
+            }
+            return { success: false, status: response.status };
+        }
+        catch (error) {
+            clearTimeout(timer);
+            if (isAbortError(error)) {
+                return { success: false, error: 'Request timed out' };
+            }
+            return { success: false, error: resolveErrorMessage(error) };
+        }
+    }
+    return { success: false, error: 'Too many redirects' };
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,25 @@
+export type Verbosity = 'quiet' | 'normal' | 'verbose';
+export declare class Logger {
+    private verbosity;
+    private terminalEnabled;
+    private readonly logDir;
+    private readonly logPath;
+    constructor(options?: {
+        rootDir?: string;
+        verbosity?: Verbosity;
+        terminalEnabled?: boolean;
+        logDir?: string;
+        logFile?: string;
+    });
+    setVerbosity(level: Verbosity): void;
+    setTerminalEnabled(enabled: boolean): void;
+    debug(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    private write;
+    private shouldLog;
+    private ensureLogDir;
+    private rotateIfNeeded;
+}
+export declare const DEFAULT_LOG_PATH = ".watchfix/daemon.log";

package/dist/utils/logger.js

@@ -0,0 +1,85 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const LOG_ROTATION = {
+    maxSize: 10 * 1024 * 1024,
+    maxFiles: 5,
+};
+const VERBOSITY_LEVELS = {
+    quiet: ['WARN', 'ERROR'],
+    normal: ['INFO', 'WARN', 'ERROR'],
+    verbose: ['DEBUG', 'INFO', 'WARN', 'ERROR'],
+};
+export class Logger {
+    verbosity;
+    terminalEnabled;
+    logDir;
+    logPath;
+    constructor(options) {
+        const rootDir = options?.rootDir ?? process.cwd();
+        this.logDir = options?.logDir ?? path.join(rootDir, '.watchfix');
+        const logFile = options?.logFile ?? 'daemon.log';
+        this.logPath = path.join(this.logDir, logFile);
+        this.verbosity = options?.verbosity ?? 'normal';
+        this.terminalEnabled = options?.terminalEnabled ?? true;
+    }
+    setVerbosity(level) {
+        this.verbosity = level;
+    }
+    setTerminalEnabled(enabled) {
+        this.terminalEnabled = enabled;
+    }
+    debug(message) {
+        this.write('DEBUG', message);
+    }
+    info(message) {
+        this.write('INFO', message);
+    }
+    warn(message) {
+        this.write('WARN', message);
+    }
+    error(message) {
+        this.write('ERROR', message);
+    }
+    write(level, message) {
+        if (!this.shouldLog(level)) {
+            return;
+        }
+        this.ensureLogDir();
+        this.rotateIfNeeded();
+        const line = `${new Date().toISOString()} [${level}] ${message}\n`;
+        fs.appendFileSync(this.logPath, line, 'utf8');
+        if (this.terminalEnabled) {
+            process.stderr.write(line);
+        }
+    }
+    shouldLog(level) {
+        return VERBOSITY_LEVELS[this.verbosity].includes(level);
+    }
+    ensureLogDir() {
+        if (!fs.existsSync(this.logDir)) {
+            fs.mkdirSync(this.logDir, { recursive: true });
+        }
+    }
+    rotateIfNeeded() {
+        if (!fs.existsSync(this.logPath)) {
+            return;
+        }
+        const { size } = fs.statSync(this.logPath);
+        if (size < LOG_ROTATION.maxSize) {
+            return;
+        }
+        const oldest = `${this.logPath}.${LOG_ROTATION.maxFiles}`;
+        if (fs.existsSync(oldest)) {
+            fs.rmSync(oldest);
+        }
+        for (let index = LOG_ROTATION.maxFiles - 1; index >= 1; index -= 1) {
+            const source = `${this.logPath}.${index}`;
+            const destination = `${this.logPath}.${index + 1}`;
+            if (fs.existsSync(source)) {
+                fs.renameSync(source, destination);
+            }
+        }
+        fs.renameSync(this.logPath, `${this.logPath}.1`);
+    }
+}
+export const DEFAULT_LOG_PATH = '.watchfix/daemon.log';

package/dist/utils/process.d.ts

@@ -0,0 +1,16 @@
+import { type SpawnOptions } from 'node:child_process';
+export interface CliCheckResult {
+    exists: boolean;
+    version?: string;
+    error?: string;
+}
+export interface SpawnResult {
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    timedOut: boolean;
+}
+export declare function checkCliExists(command: string): CliCheckResult;
+export declare function spawnWithTimeout(command: string, args: string[], options: SpawnOptions | undefined, timeoutMs: number): Promise<SpawnResult>;
+export declare function isOurProcess(pid: number, expectedRoot: string): boolean;