@mod-computer/cli 0.2.4 → 0.2.5

package/dist/daemon/worker.js

@@ -1,557 +0,0 @@
-#!/usr/bin/env node
-// glassware[type="implementation", id="cli-daemon-worker--f5cd12a8", requirements="requirement-cli-sync-app-3--c2dca5d7,requirement-cli-sync-app-4--ed3c2529,requirement-cli-sync-app-5--a969b725,requirement-cli-sync-qual-3--99893467,requirement-cli-sync-qual-5--3d62024d,requirement-cli-sync-infra-1--4ec9e05c,requirement-cli-files-app-2--6765b2c1,requirement-cli-files-app-3--552aece6,requirement-cli-files-app-4--c5ef157e"]
-// glassware[type="implementation", id="impl-daemon-worker-distributed--2503a678", specifications="specification-spec-daemon-process--ed4facd5,specification-spec-daemon-websocket--708091f7,specification-spec-daemon-reconnect--1da6516e,specification-spec-daemon-backoff--0fa7d2ed,specification-spec-reconnect-logging--54499791,specification-spec-file-watch--ec0b56ec,specification-spec-offline-cli--c444a9a2,specification-spec-offline-persist--f4fc5073,specification-spec-sync-on-start--d1b0cc16"]
-// glassware[type="implementation", id="impl-daemon-offline-integration--4650abf8", requirements="requirement-cli-sync-offline-queue--08f04bd5,requirement-cli-sync-queue-persist--e35cadaa,requirement-cli-sync-queue-replay--a7954975"]
-// glassware[type="implementation", id="impl-daemon-wasm-integration--272a8dda", requirements="requirement-cli-sync-wasm-detect--5517bb61,requirement-cli-sync-wasm-recover--ca8c0cb6"]
-// glassware[type="implementation", id="impl-daemon-git-branch-scoping--7796ecba", requirements="requirement-cli-git-ux-2--e0fdbd0e,requirement-cli-git-app-4--ffac806a,requirement-cli-git-app-5--d0f0cbd5,requirement-cli-git-qual-3--5af20852"]
-/**
- * Daemon worker - runs as a background process watching directories.
- * Loads workspace connections from ~/.mod/workspaces/ and watches each.
- * Syncs file changes to Automerge documents in the workspace.
- *
- * Features:
- * - Offline queue: Changes are queued when offline and replayed on reconnect
- * - WASM error recovery: Automerge WASM errors are caught and retried
- * - Conflict resolution: Last-write-wins with conflict logging
- */
-import fs from 'fs';
-import path from 'path';
-import chokidar from 'chokidar';
-import { repo as getRepo } from '@mod/mod-core/repos/repo.node';
-import { cliSharePolicy } from './share-policy.js';
-import { listWorkspaceConnections, getSyncLogPath, getLogsDir, readConfig, } from '../lib/storage.js';
-import { detectGitRepo, readCurrentBranch, isGitOperationInProgress } from '../lib/git.js';
-import { createFileSyncContext, handleFileCreate, handleFileChange, handleFileDelete, performInitialSync, subscribeToRemoteChanges, cleanupRemoteSubscriptions, isPendingWrite, } from './file-sync.js';
-import { DEFAULT_IGNORE_PATTERNS, shouldIgnore } from '@mod/mod-core';
-import { OfflineQueueManager } from './offline-queue.js';
-import { WasmErrorRecovery } from './wasm-errors.js';
-import { normalizePath } from './path-utils.js';
-class DaemonWorker {
-    constructor() {
-        this.repo = null;
-        this.watchers = new Map();
-        this.headWatchers = new Map();
-        this.fileSyncContexts = new Map();
-        this.connections = [];
-        this.debounceTimers = new Map();
-        this.debounceMs = 100;
-        this.isShuttingDown = false;
-        this.gitBranches = new Map();
-        // Run initial sync by default (can be disabled with MOD_INITIAL_SYNC=false)
-        this.runInitialSync = process.env.MOD_INITIAL_SYNC !== 'false';
-        // Track online/offline state
-        this.isOnline = true;
-        this.offlineQueue = new OfflineQueueManager((msg) => this.log(msg));
-        this.wasmRecovery = new WasmErrorRecovery({
-            maxRetries: 3,
-            baseDelayMs: 100,
-            logger: (msg) => this.log(msg),
-        });
-    }
-    async start() {
-        this.log('Daemon worker starting');
-        // Initialize Automerge repo with CLI sharePolicy
-        try {
-            this.repo = await getRepo({ sharePolicy: cliSharePolicy });
-            this.log('Automerge repo initialized with scoped sharePolicy');
-        }
-        catch (error) {
-            this.log(`Failed to initialize Automerge repo: ${error?.message || error}`);
-            process.exit(1);
-        }
-        // Load workspace connections
-        this.connections = listWorkspaceConnections();
-        if (this.connections.length === 0) {
-            this.log('No workspace connections found, exiting');
-            process.exit(0);
-        }
-        this.log(`Found ${this.connections.length} workspace connection(s)`);
-        // Start watching each connected directory
-        for (const connection of this.connections) {
-            await this.watchDirectory(connection);
-        }
-        // Check auth state
-        const config = readConfig();
-        if (config.auth) {
-            this.log(`Authenticated as ${config.auth.email}`);
-            // Cloud sync is handled automatically by mod-core repo with WebSocket
-        }
-        else {
-            this.log('Running in local-only mode (not authenticated)');
-        }
-        // Set up shutdown handlers
-        process.on('SIGTERM', () => this.shutdown('SIGTERM'));
-        process.on('SIGINT', () => this.shutdown('SIGINT'));
-        // Periodically check for new workspace connections
-        setInterval(() => this.checkForNewConnections(), 30000);
-        // Start WASM error recovery periodic processing
-        this.wasmRecovery.startPeriodicProcessing(1000);
-        // Replay any queued offline changes
-        if (this.offlineQueue.hasPending()) {
-            this.log(`Found ${this.offlineQueue.getPendingCount()} pending offline changes, replaying...`);
-            await this.replayOfflineQueue();
-        }
-        this.log('Daemon worker ready');
-    }
-    /**
-     * Replay offline queue changes after reconnection.
-     */
-    async replayOfflineQueue() {
-        const result = await this.offlineQueue.replay(async (change) => {
-            const connection = this.connections.find(c => c.workspaceId === change.workspaceId);
-            if (!connection) {
-                this.log(`[offline-queue] No connection found for workspace ${change.workspaceId}`);
-                return false;
-            }
-            const ctx = this.fileSyncContexts.get(connection.path);
-            if (!ctx) {
-                this.log(`[offline-queue] No sync context for ${connection.path}`);
-                return false;
-            }
-            const absolutePath = path.join(connection.path, change.relativePath);
-            try {
-                switch (change.type) {
-                    case 'create':
-                    case 'update':
-                        if (fs.existsSync(absolutePath)) {
-                            await handleFileChange(ctx, absolutePath);
-                        }
-                        break;
-                    case 'delete':
-                        await handleFileDelete(ctx, absolutePath);
-                        break;
-                }
-                return true;
-            }
-            catch (error) {
-                this.log(`[offline-queue] Error replaying ${change.relativePath}: ${error?.message || error}`);
-                return false;
-            }
-        });
-        this.log(`[offline-queue] Replay complete: ${result.synced} synced, ${result.failed} failed`);
-    }
-    async watchDirectory(connection) {
-        if (!fs.existsSync(connection.path)) {
-            this.log(`Directory not found: ${connection.path}, skipping`);
-            return;
-        }
-        if (!this.repo) {
-            this.log(`Repo not initialized, cannot watch ${connection.path}`);
-            return;
-        }
-        // Detect git repo and branch
-        const gitInfo = detectGitRepo(connection.path);
-        const gitBranch = gitInfo.isGitRepo ? gitInfo.branch : null;
-        this.log(`[git-detect] detectGitRepo(${connection.path}): isGitRepo=${gitInfo.isGitRepo}, branch=${gitInfo.branch}, headFile=${gitInfo.headFile}`);
-        if (gitInfo.isGitRepo) {
-            this.gitBranches.set(connection.path, gitBranch);
-            this.log(`Watching: ${connection.path} → ${connection.workspaceName} (git branch: ${gitBranch || 'unknown'})`);
-            // Watch .git/HEAD for branch changes
-            if (gitInfo.headFile) {
-                this.log(`[git-detect] Calling watchGitHead with headFile: ${gitInfo.headFile}`);
-                this.watchGitHead(connection, gitInfo.headFile);
-            }
-            else {
-                this.log(`[git-detect] No headFile found, skipping watchGitHead`);
-            }
-        }
-        else {
-            this.gitBranches.set(connection.path, null);
-            this.log(`Watching: ${connection.path} → ${connection.workspaceName} (not a git repo)`);
-        }
-        // Create file sync context with logger
-        try {
-            const ctx = await createFileSyncContext(this.repo, connection, gitBranch, (msg) => this.log(msg));
-            this.fileSyncContexts.set(connection.path, ctx);
-            this.log(`File sync context created for ${connection.workspaceName}`);
-            // Run initial sync if enabled
-            if (this.runInitialSync) {
-                const ignorePatterns = this.loadIgnorePatterns(connection.path);
-                this.log(`Running initial sync for ${connection.workspaceName}...`);
-                const stats = await performInitialSync(ctx, ignorePatterns);
-                this.log(`Initial sync complete: ${stats.synced} files synced, ${stats.skipped} skipped`);
-            }
-            // Subscribe to remote changes for bidirectional sync
-            await subscribeToRemoteChanges(ctx);
-        }
-        catch (error) {
-            this.log(`Failed to create file sync context for ${connection.workspaceName}: ${error?.message || error}`);
-        }
-        // Load ignore patterns
-        const ignorePatterns = this.loadIgnorePatterns(connection.path);
-        const watcher = chokidar.watch(connection.path, {
-            ignored: ignorePatterns,
-            persistent: true,
-            ignoreInitial: true,
-            awaitWriteFinish: {
-                stabilityThreshold: 100,
-                pollInterval: 50,
-            },
-        });
-        watcher.on('add', (filePath) => this.handleFileChange(connection, filePath, 'add'));
-        watcher.on('change', (filePath) => this.handleFileChange(connection, filePath, 'change'));
-        watcher.on('unlink', (filePath) => this.handleFileChange(connection, filePath, 'unlink'));
-        watcher.on('error', (error) => {
-            this.log(`Watcher error for ${connection.path}: ${error.message}`);
-        });
-        this.watchers.set(connection.path, watcher);
-    }
-    // glassware[type="implementation", id="impl-cli-watch-git-head--fde1da6d", specifications="specification-spec-watch-head--e3035ccf"]
-    watchGitHead(connection, headFile) {
-        // Watch the .git/HEAD file for branch changes
-        this.log(`[git-head] Setting up HEAD watcher for ${connection.workspaceName}: ${headFile}`);
-        const headWatcher = chokidar.watch(headFile, {
-            persistent: true,
-            ignoreInitial: true,
-        });
-        headWatcher.on('change', async () => {
-            const newBranch = readCurrentBranch(headFile);
-            const oldBranch = this.gitBranches.get(connection.path);
-            this.log(`[git-head] HEAD file changed: ${headFile}, old=${oldBranch}, new=${newBranch}`);
-            if (newBranch !== oldBranch) {
-                await this.handleBranchSwitch(connection, oldBranch, newBranch);
-            }
-        });
-        headWatcher.on('error', (error) => {
-            this.log(`Git HEAD watcher error for ${connection.path}: ${error.message}`);
-        });
-        this.headWatchers.set(connection.path, headWatcher);
-    }
-    /**
-     * Handle git branch switch.
-     * Updates connection state, logs the change, and re-scopes sync.
-     */
-    // glassware[type="implementation", id="impl-cli-handle-branch-switch--87dd375f", specifications="specification-spec-branch-switch--243409fb"]
-    async handleBranchSwitch(connection, oldBranch, newBranch) {
-        // Update git branch tracking
-        this.gitBranches.set(connection.path, newBranch);
-        // Log branch change per spec requirement cli-git-ux-2
-        this.log(`Git branch changed: ${oldBranch || 'unknown'} → ${newBranch || 'unknown'}`);
-        this.log(`Re-scoping sync to branch: ${newBranch || 'default'}`);
-        // Update file sync context with new branch
-        const ctx = this.fileSyncContexts.get(connection.path);
-        if (ctx) {
-            // Update the context's git branch
-            ctx.gitBranch = newBranch;
-            // Record the branch detection so web app sees the change
-            this.log(`[branch-switch] ctx.gitBranchService=${!!ctx.gitBranchService}, newBranch=${newBranch}`);
-            if (ctx.gitBranchService && newBranch) {
-                try {
-                    // Source ID must match pattern: cli:<alphanumeric-id>
-                    const clientId = connection.workspaceId.replace(/[^a-zA-Z0-9_-]/g, '').slice(0, 20);
-                    const sourceId = `cli:${clientId}`;
-                    await ctx.gitBranchService.recordDetection(connection.workspaceId, sourceId, {
-                        branch: newBranch,
-                        revision: null,
-                        dirty: false,
-                        detached: false
-                    });
-                    this.log(`Recorded branch detection for: ${newBranch}`);
-                }
-                catch (error) {
-                    this.log(`Failed to record branch detection: ${error?.message || error}`);
-                }
-            }
-            // Re-sync directory for new branch
-            await this.resyncDirectory(connection, ctx);
-        }
-    }
-    /**
-     * Re-sync directory after branch switch.
-     * Hydrates local state from workspace documents tagged with the current branch.
-     *
-     * spec-branch-switch--wip: Handles branch switching in CLI
-     */
-    // glassware[type="implementation", id="impl-daemon-resync-directory--43425a12", specifications="specification-spec-branch-switch--243409fb,specification-spec-git-operations--addf801f"]
-    async resyncDirectory(connection, ctx) {
-        const branch = ctx.gitBranch;
-        const logPrefix = `[${connection.workspaceName}][${branch || 'default'}]`;
-        this.log(`${logPrefix} Re-syncing directory for branch: ${branch || 'default'}`);
-        // Check if a git operation is in progress - if so, wait briefly
-        if (await isGitOperationInProgress(connection.path)) {
-            this.log(`${logPrefix} Git operation in progress, waiting before resync...`);
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            // Check again - if still in progress, skip this sync cycle
-            if (await isGitOperationInProgress(connection.path)) {
-                this.log(`${logPrefix} Git operation still in progress, skipping resync`);
-                return;
-            }
-        }
-        if (!branch) {
-            this.log(`${logPrefix} No branch context, using default behavior`);
-            return;
-        }
-        try {
-            // Get the branch tree using listTree (works with the OLD format that applyOverride writes to)
-            const treeResult = await ctx.workspace.gitBranch.listTree({ branch });
-            const overrides = treeResult.overrides || {};
-            const inherited = treeResult.inherited || {};
-            this.log(`${logPrefix} Branch tree: ${Object.keys(overrides).length} overrides, ${Object.keys(inherited).length} inherited`);
-            if (Object.keys(overrides).length > 0) {
-                this.log(`${logPrefix} Override files: ${Object.keys(overrides).join(', ')}`);
-            }
-            // Combine overrides and inherited for full tree (path -> documentId)
-            const allFiles = { ...inherited, ...overrides }; // overrides take precedence
-            const inheritedPaths = new Set(Object.keys(inherited));
-            // Clear existing caches to rebuild from branch state
-            ctx.filePathCache.clear();
-            ctx.docIdToPathCache.clear();
-            // Populate caches from branch tree
-            for (const [relativePath, docIdStr] of Object.entries(allFiles)) {
-                const docId = docIdStr;
-                ctx.filePathCache.set(relativePath, docId);
-                ctx.docIdToPathCache.set(docId, relativePath);
-            }
-            // Materialize branch-specific files to local filesystem if they differ
-            // Only materialize files that are NOT inherited (branch-specific changes)
-            const branchSpecificPaths = Object.keys(overrides);
-            this.log(`${logPrefix} ${branchSpecificPaths.length} branch-specific files to check`);
-            for (const relativePath of branchSpecificPaths) {
-                const docIdStr = overrides[relativePath];
-                const absolutePath = path.join(connection.path, relativePath);
-                try {
-                    // Get the document content
-                    const fileHandle = await ctx.workspace.file.get(docIdStr);
-                    if (!fileHandle) {
-                        this.log(`${logPrefix} Could not get file handle for: ${relativePath}`);
-                        continue;
-                    }
-                    const doc = fileHandle.doc();
-                    if (!doc)
-                        continue;
-                    // Check if local file exists and differs
-                    let shouldWrite = false;
-                    if (!fs.existsSync(absolutePath)) {
-                        shouldWrite = true;
-                    }
-                    else {
-                        // Compare content hash if available
-                        const localContent = fs.readFileSync(absolutePath);
-                        const localHash = (await import('./content-hash.js')).computeContentHash(localContent);
-                        const remoteHash = doc.metadata?.contentHash;
-                        if (remoteHash && localHash !== remoteHash) {
-                            shouldWrite = true;
-                        }
-                    }
-                    if (shouldWrite) {
-                        // Mark as pending write to avoid circular update
-                        ctx.pendingWrites.set(relativePath, Date.now() + 2000);
-                        // Ensure parent directory exists
-                        const parentDir = path.dirname(absolutePath);
-                        if (!fs.existsSync(parentDir)) {
-                            fs.mkdirSync(parentDir, { recursive: true });
-                        }
-                        // Write content to local filesystem
-                        const content = doc.text || doc.binary;
-                        if (doc.binary) {
-                            fs.writeFileSync(absolutePath, Buffer.from(doc.binary, 'base64'));
-                        }
-                        else if (content) {
-                            const { getTextContent } = await import('@mod/mod-core');
-                            const textContent = getTextContent(fileHandle, ['text']);
-                            fs.writeFileSync(absolutePath, textContent || '');
-                        }
-                        this.log(`${logPrefix} Materialized branch file: ${relativePath}`);
-                    }
-                }
-                catch (error) {
-                    this.log(`${logPrefix} Error materializing ${relativePath}: ${error?.message || error}`);
-                }
-            }
-            this.log(`${logPrefix} Branch resync complete`);
-        }
-        catch (error) {
-            this.log(`${logPrefix} Error during resync: ${error?.message || error}`);
-            // Fall back to basic behavior
-            this.log(`${logPrefix} Branch context updated, sync will use branch: ${branch || 'default'}`);
-        }
-    }
-    loadIgnorePatterns(directoryPath) {
-        const patterns = [...DEFAULT_IGNORE_PATTERNS];
-        // Load .modignore if it exists
-        const modignorePath = path.join(directoryPath, '.modignore');
-        if (fs.existsSync(modignorePath)) {
-            try {
-                const content = fs.readFileSync(modignorePath, 'utf-8');
-                const customPatterns = content
-                    .split('\n')
-                    .map((line) => line.trim())
-                    .filter((line) => line && !line.startsWith('#'));
-                patterns.push(...customPatterns);
-            }
-            catch (error) {
-                this.log(`Could not read .modignore: ${error?.message || error}`);
-            }
-        }
-        return patterns;
-    }
-    handleFileChange(connection, filePath, event) {
-        // Debounce rapid changes
-        const key = filePath;
-        const existingTimer = this.debounceTimers.get(key);
-        if (existingTimer) {
-            clearTimeout(existingTimer);
-        }
-        const timer = setTimeout(() => {
-            this.debounceTimers.delete(key);
-            this.processFileChange(connection, filePath, event);
-        }, this.debounceMs);
-        this.debounceTimers.set(key, timer);
-    }
-    async processFileChange(connection, filePath, event) {
-        const relativePath = normalizePath(filePath, connection.path);
-        const branch = this.gitBranches.get(connection.path);
-        const branchPrefix = branch ? `[${branch}]` : '';
-        const logPrefix = `[${connection.workspaceName}]${branchPrefix}`;
-        // Defensive check: skip ignored files (chokidar should filter, but double-check)
-        if (shouldIgnore(relativePath)) {
-            // Don't log to avoid noise - this is just a safety net
-            return;
-        }
-        // Get file sync context
-        const ctx = this.fileSyncContexts.get(connection.path);
-        if (!ctx) {
-            this.log(`${logPrefix} No sync context, skipping: ${relativePath}`);
-            return;
-        }
-        // Skip if this is a pending write from remote sync (avoid circular updates)
-        if (isPendingWrite(ctx, relativePath)) {
-            this.log(`${logPrefix} Skipping pending write: ${relativePath}`);
-            return;
-        }
-        // Don't sync during active git operations (rebase, merge, etc.)
-        if (isGitOperationInProgress(connection.path)) {
-            this.log(`${logPrefix} Git operation in progress, skipping: ${relativePath}`);
-            return;
-        }
-        // If offline, queue the change for later
-        if (!this.isOnline) {
-            this.log(`${logPrefix} Offline, queuing: ${relativePath}`);
-            this.offlineQueue.add({
-                type: event === 'add' ? 'create' : event === 'unlink' ? 'delete' : 'update',
-                relativePath,
-                workspaceId: connection.workspaceId,
-            });
-            return;
-        }
-        // Execute with WASM error recovery
-        const result = await this.wasmRecovery.executeWithRecovery(`${connection.workspaceId}:${relativePath}`, async () => {
-            switch (event) {
-                case 'add':
-                    this.log(`${logPrefix} File added: ${relativePath}`);
-                    await handleFileCreate(ctx, filePath);
-                    break;
-                case 'change':
-                    this.log(`${logPrefix} File changed: ${relativePath}`);
-                    await handleFileChange(ctx, filePath);
-                    break;
-                case 'unlink':
-                    this.log(`${logPrefix} File deleted: ${relativePath}`);
-                    await handleFileDelete(ctx, filePath);
-                    break;
-            }
-            return true;
-        });
-        if (result === null) {
-            // WASM error occurred, already queued for retry
-            this.log(`${logPrefix} WASM error for ${relativePath}, queued for retry`);
-        }
-    }
-    /**
-     * Set online/offline state. When going online, replay queued changes.
-     */
-    async setOnlineState(online) {
-        if (this.isOnline === online)
-            return;
-        this.isOnline = online;
-        this.log(`Connection state changed: ${online ? 'online' : 'offline'}`);
-        if (online && this.offlineQueue.hasPending()) {
-            this.log('Back online, replaying offline queue...');
-            await this.replayOfflineQueue();
-        }
-    }
-    async checkForNewConnections() {
-        const currentConnections = listWorkspaceConnections();
-        // Check for new connections
-        for (const connection of currentConnections) {
-            if (!this.watchers.has(connection.path)) {
-                this.log(`New workspace connection detected: ${connection.path}`);
-                await this.watchDirectory(connection);
-            }
-        }
-        // Check for removed connections
-        for (const watchedPath of this.watchers.keys()) {
-            if (!currentConnections.some((c) => c.path === watchedPath)) {
-                this.log(`Workspace connection removed: ${watchedPath}`);
-                const watcher = this.watchers.get(watchedPath);
-                if (watcher) {
-                    await watcher.close();
-                    this.watchers.delete(watchedPath);
-                }
-                // Also cleanup git HEAD watcher
-                const headWatcher = this.headWatchers.get(watchedPath);
-                if (headWatcher) {
-                    await headWatcher.close();
-                    this.headWatchers.delete(watchedPath);
-                }
-                // Cleanup file sync context
-                this.fileSyncContexts.delete(watchedPath);
-                this.gitBranches.delete(watchedPath);
-            }
-        }
-        this.connections = currentConnections;
-    }
-    async shutdown(signal) {
-        if (this.isShuttingDown)
-            return;
-        this.isShuttingDown = true;
-        this.log(`Received ${signal}, shutting down...`);
-        // Stop WASM recovery processing
-        this.wasmRecovery.stopPeriodicProcessing();
-        this.log('Stopped WASM recovery processing');
-        // Cleanup remote change subscriptions
-        for (const [watchPath, ctx] of this.fileSyncContexts) {
-            cleanupRemoteSubscriptions(ctx);
-            this.log(`Cleaned up subscriptions for ${watchPath}`);
-        }
-        // Close all file watchers
-        for (const [watchPath, watcher] of this.watchers) {
-            await watcher.close();
-            this.log(`Closed watcher for ${watchPath}`);
-        }
-        // Close all git HEAD watchers
-        for (const [watchPath, watcher] of this.headWatchers) {
-            await watcher.close();
-            this.log(`Closed git HEAD watcher for ${watchPath}`);
-        }
-        // Clear debounce timers
-        for (const timer of this.debounceTimers.values()) {
-            clearTimeout(timer);
-        }
-        this.log('Daemon worker stopped');
-        process.exit(0);
-    }
-    log(message) {
-        const timestamp = new Date().toISOString();
-        const line = `${timestamp} [INFO] ${message}\n`;
-        // Write to log file
-        try {
-            const logPath = getSyncLogPath();
-            const logDir = getLogsDir();
-            if (!fs.existsSync(logDir)) {
-                fs.mkdirSync(logDir, { recursive: true });
-            }
-            fs.appendFileSync(logPath, line);
-        }
-        catch (error) {
-            // Fall back to console if logging fails
-            console.log(line);
-        }
-    }
-}
-// Start the daemon worker
-const worker = new DaemonWorker();
-worker.start().catch((error) => {
-    console.error('Daemon worker failed to start:', error);
-    process.exit(1);
-});