@mod-computer/cli 0.2.3 → 0.2.5

package/dist/daemon/index.js

@@ -1,203 +0,0 @@
-// glassware[type="implementation", id="cli-daemon-manager--4c5e461e", requirements="requirement-cli-sync-app-1--6a95c316,requirement-cli-sync-app-2--849a3392,requirement-cli-sync-infra-3--e8b62ac3,requirement-cli-storage-pid-1--ab7339a0,requirement-cli-storage-pid-2--a78c87bb,requirement-cli-storage-pid-3--48975e4c,requirement-cli-storage-pid-4--35d0f765"]
-// glassware[type="implementation", id="impl-daemon-manager-distributed--f5e77099", specifications="specification-spec-sync-start--cd4dcfee,specification-spec-sync-stop--ea84706e,specification-spec-status-command--0fb19514,specification-spec-status-states--3f110d43,specification-spec-status-timestamp--120c109a"]
-/**
- * Sync daemon management - handles start/stop/status for background sync process.
- * Uses device-level state in ~/.mod/
- */
-import fs from 'fs';
-import path from 'path';
-import { spawn } from 'child_process';
-import { fileURLToPath } from 'url';
-import { getPidFilePath, getLogsDir, getSyncLogPath, listWorkspaceConnections, readConfig, ensureModDir, } from '../lib/storage.js';
-import { getGitBranch } from '../lib/git.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-/**
- * Check if daemon is currently running.
- */
-export function isDaemonRunning() {
-    const pidPath = getPidFilePath();
-    if (!fs.existsSync(pidPath)) {
-        return { running: false };
-    }
-    try {
-        const pidStr = fs.readFileSync(pidPath, 'utf-8').trim();
-        const pid = parseInt(pidStr, 10);
-        if (isNaN(pid)) {
-            // Corrupted PID file, clean up
-            fs.unlinkSync(pidPath);
-            return { running: false };
-        }
-        // Check if process is running
-        try {
-            process.kill(pid, 0);
-            return { running: true, pid };
-        }
-        catch {
-            // Process not running, clean up stale PID file
-            fs.unlinkSync(pidPath);
-            return { running: false };
-        }
-    }
-    catch (error) {
-        return { running: false };
-    }
-}
-/**
- * Start the sync daemon.
- */
-export async function startDaemon(options) {
-    ensureModDir();
-    // Check if already running
-    const { running, pid: existingPid } = isDaemonRunning();
-    if (running) {
-        return {
-            success: true,
-            pid: existingPid,
-            message: `Sync daemon already running (pid ${existingPid})`,
-        };
-    }
-    // Check for workspace connections
-    const connections = listWorkspaceConnections();
-    if (connections.length === 0) {
-        return {
-            success: false,
-            message: 'No workspace connections found. Run `mod init` first.',
-        };
-    }
-    // Spawn daemon process
-    const daemonScript = path.join(__dirname, 'worker.js');
-    // Check if worker script exists
-    if (!fs.existsSync(daemonScript)) {
-        return {
-            success: false,
-            message: 'Daemon worker script not found. Build may be incomplete.',
-        };
-    }
-    const logPath = getSyncLogPath();
-    const logDir = getLogsDir();
-    // Ensure logs directory exists
-    if (!fs.existsSync(logDir)) {
-        fs.mkdirSync(logDir, { recursive: true });
-    }
-    // Open log file for daemon output
-    const logFd = fs.openSync(logPath, 'a');
-    const daemon = spawn(process.execPath, [daemonScript], {
-        detached: true,
-        stdio: options?.verbose ? 'inherit' : ['ignore', logFd, logFd],
-        env: {
-            ...process.env,
-            MOD_DAEMON_MODE: 'true',
-        },
-    });
-    daemon.unref();
-    fs.closeSync(logFd);
-    if (!daemon.pid) {
-        return {
-            success: false,
-            message: 'Failed to spawn daemon process',
-        };
-    }
-    // Write PID file
-    fs.writeFileSync(getPidFilePath(), daemon.pid.toString());
-    // Check auth state for messaging
-    const config = readConfig();
-    const isAuthenticated = !!config.auth;
-    const directories = connections.map((c) => c.path).join(', ');
-    if (isAuthenticated) {
-        return {
-            success: true,
-            pid: daemon.pid,
-            message: `Sync daemon started (pid ${daemon.pid})\nWatching: ${directories}\nSyncing with collaborators`,
-        };
-    }
-    else {
-        return {
-            success: true,
-            pid: daemon.pid,
-            message: `Sync daemon started (pid ${daemon.pid})\nWatching: ${directories}\nTracking changes locally\n\nSign in to sync with collaborators: mod auth login`,
-        };
-    }
-}
-/**
- * Stop the sync daemon.
- */
-export async function stopDaemon(options) {
-    const { running, pid } = isDaemonRunning();
-    if (!running || !pid) {
-        return {
-            success: true,
-            message: 'Sync daemon not running',
-        };
-    }
-    try {
-        // Send SIGTERM for graceful shutdown
-        process.kill(pid, 'SIGTERM');
-        // Wait for process to exit (up to 5 seconds)
-        let attempts = 50;
-        while (attempts > 0) {
-            try {
-                process.kill(pid, 0);
-                await new Promise((resolve) => setTimeout(resolve, 100));
-                attempts--;
-            }
-            catch {
-                // Process exited
-                break;
-            }
-        }
-        // Force kill if still running
-        if (attempts === 0 && options?.force) {
-            try {
-                process.kill(pid, 'SIGKILL');
-            }
-            catch {
-                // Process already gone
-            }
-        }
-        // Clean up PID file
-        const pidPath = getPidFilePath();
-        if (fs.existsSync(pidPath)) {
-            fs.unlinkSync(pidPath);
-        }
-        return {
-            success: true,
-            message: 'Sync daemon stopped',
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            message: `Failed to stop daemon: ${error.message}`,
-        };
-    }
-}
-// glassware[type="implementation", id="impl-daemon-status-git-branch--80bdc2eb", requirements="requirement-cli-git-ux-1--01756c1e,requirement-cli-git-ux-3--6137e6b6"]
-/**
- * Get daemon status.
- */
-export function getDaemonStatus() {
-    const { running, pid } = isDaemonRunning();
-    const connections = listWorkspaceConnections();
-    const config = readConfig();
-    let cloudSync;
-    if (!config.auth) {
-        cloudSync = 'not_signed_in';
-    }
-    else {
-        // TODO: Check actual WebSocket connection status
-        cloudSync = 'connected';
-    }
-    return {
-        running,
-        pid,
-        connections: connections.map((c) => ({
-            path: c.path,
-            workspaceName: c.workspaceName,
-            gitBranch: getGitBranch(c.path),
-        })),
-        cloudSync,
-        lastSync: connections[0]?.lastSyncedAt,
-        pendingChanges: 0, // TODO: Track pending changes
-    };
-}

package/dist/daemon/mime-types.js

@@ -1,166 +0,0 @@
-// glassware[type="implementation", id="impl-mime-types--c09c1b7f", requirements="requirement-cli-sync-mime-detect--a84702ed"]
-/**
- * MIME type detection for file sync.
- * Maps file extensions to MIME types.
- */
-import path from 'path';
-/**
- * MIME type mappings by file extension.
- */
-export const MIME_TYPES = {
-    // Text
-    '.txt': 'text/plain',
-    '.md': 'text/markdown',
-    '.markdown': 'text/markdown',
-    // TypeScript/JavaScript
-    '.ts': 'text/typescript',
-    '.tsx': 'text/typescript',
-    '.js': 'text/javascript',
-    '.jsx': 'text/javascript',
-    '.mjs': 'text/javascript',
-    '.cjs': 'text/javascript',
-    // Web
-    '.html': 'text/html',
-    '.htm': 'text/html',
-    '.css': 'text/css',
-    '.scss': 'text/scss',
-    '.sass': 'text/sass',
-    '.less': 'text/less',
-    // Data/Config
-    '.json': 'application/json',
-    '.yaml': 'text/yaml',
-    '.yml': 'text/yaml',
-    '.toml': 'text/toml',
-    '.xml': 'application/xml',
-    '.svg': 'image/svg+xml',
-    // Programming languages
-    '.py': 'text/x-python',
-    '.rb': 'text/x-ruby',
-    '.go': 'text/x-go',
-    '.rs': 'text/x-rust',
-    '.java': 'text/x-java',
-    '.c': 'text/x-c',
-    '.cpp': 'text/x-c++',
-    '.cc': 'text/x-c++',
-    '.h': 'text/x-c',
-    '.hpp': 'text/x-c++',
-    '.cs': 'text/x-csharp',
-    '.swift': 'text/x-swift',
-    '.kt': 'text/x-kotlin',
-    '.scala': 'text/x-scala',
-    '.php': 'text/x-php',
-    // Shell/Scripts
-    '.sh': 'text/x-shellscript',
-    '.bash': 'text/x-shellscript',
-    '.zsh': 'text/x-shellscript',
-    '.fish': 'text/x-shellscript',
-    '.ps1': 'text/x-powershell',
-    '.bat': 'text/x-batch',
-    // Database/Query
-    '.sql': 'text/x-sql',
-    '.graphql': 'text/x-graphql',
-    '.gql': 'text/x-graphql',
-    // Documentation
-    '.rst': 'text/x-rst',
-    '.tex': 'text/x-latex',
-    '.adoc': 'text/asciidoc',
-    // Config files
-    '.env': 'text/plain',
-    '.ini': 'text/plain',
-    '.cfg': 'text/plain',
-    '.conf': 'text/plain',
-    '.gitignore': 'text/plain',
-    '.dockerignore': 'text/plain',
-    '.editorconfig': 'text/plain',
-    // Images
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.gif': 'image/gif',
-    '.webp': 'image/webp',
-    '.ico': 'image/x-icon',
-    '.bmp': 'image/bmp',
-    // Audio
-    '.mp3': 'audio/mpeg',
-    '.wav': 'audio/wav',
-    '.ogg': 'audio/ogg',
-    // Video
-    '.mp4': 'video/mp4',
-    '.webm': 'video/webm',
-    '.avi': 'video/x-msvideo',
-    // Documents
-    '.pdf': 'application/pdf',
-    // Archives
-    '.zip': 'application/zip',
-    '.tar': 'application/x-tar',
-    '.gz': 'application/gzip',
-    // Fonts
-    '.woff': 'font/woff',
-    '.woff2': 'font/woff2',
-    '.ttf': 'font/ttf',
-    '.otf': 'font/otf',
-    '.eot': 'application/vnd.ms-fontobject',
-};
-/**
- * Text MIME type prefixes for determining if a file is text-based.
- */
-export const TEXT_MIME_PREFIXES = [
-    'text/',
-    'application/json',
-    'application/javascript',
-    'application/typescript',
-    'application/xml',
-    'application/yaml',
-    'application/x-yaml',
-    'image/svg+xml',
-];
-/**
- * Detect MIME type from filename.
- * @param filename - Name of the file (with extension)
- * @returns MIME type string
- */
-export function detectMimeType(filename) {
-    const ext = path.extname(filename).toLowerCase();
-    return MIME_TYPES[ext] || 'application/octet-stream';
-}
-/**
- * Check if a MIME type represents a text-based file.
- * @param mimeType - MIME type string
- * @returns true if the file is text-based
- */
-export function isTextMimeType(mimeType) {
-    return TEXT_MIME_PREFIXES.some(prefix => mimeType.startsWith(prefix));
-}
-/**
- * Get language identifier from MIME type (for code highlighting).
- * @param mimeType - MIME type string
- * @returns Language identifier or undefined
- */
-export function getLanguageFromMimeType(mimeType) {
-    const languageMap = {
-        'text/typescript': 'typescript',
-        'text/javascript': 'javascript',
-        'text/x-python': 'python',
-        'text/x-ruby': 'ruby',
-        'text/x-go': 'go',
-        'text/x-rust': 'rust',
-        'text/x-java': 'java',
-        'text/x-c': 'c',
-        'text/x-c++': 'cpp',
-        'text/x-csharp': 'csharp',
-        'text/x-swift': 'swift',
-        'text/x-kotlin': 'kotlin',
-        'text/x-scala': 'scala',
-        'text/x-php': 'php',
-        'text/x-shellscript': 'shell',
-        'text/x-sql': 'sql',
-        'text/html': 'html',
-        'text/css': 'css',
-        'text/scss': 'scss',
-        'text/markdown': 'markdown',
-        'application/json': 'json',
-        'text/yaml': 'yaml',
-        'application/xml': 'xml',
-    };
-    return languageMap[mimeType];
-}

package/dist/daemon/offline-queue.js

@@ -1,211 +0,0 @@
-// glassware[type="implementation", id="impl-offline-queue--3955f31a", requirements="requirement-cli-sync-offline-queue--08f04bd5,requirement-cli-sync-queue-persist--e35cadaa,requirement-cli-sync-queue-replay--a7954975"]
-/**
- * Offline queue management for sync daemon.
- * Queues changes during offline periods and replays them on reconnect.
- * Persists queue to disk across daemon restarts.
- */
-import fs from 'fs';
-import path from 'path';
-import { getModDir } from '../lib/storage.js';
-/**
- * Get the path to the offline queue file.
- */
-export function getQueuePath() {
-    return path.join(getModDir(), 'sync-queue.json');
-}
-/**
- * Load the offline queue from disk.
- * Returns empty array if file doesn't exist or is corrupted.
- */
-export function loadQueue() {
-    const queuePath = getQueuePath();
-    if (!fs.existsSync(queuePath)) {
-        return [];
-    }
-    try {
-        const content = fs.readFileSync(queuePath, 'utf-8');
-        const queue = JSON.parse(content);
-        if (!Array.isArray(queue)) {
-            console.warn('[offline-queue] Queue file is not an array, resetting');
-            return [];
-        }
-        // Validate queue entries
-        return queue.filter((entry) => entry &&
-            typeof entry.type === 'string' &&
-            typeof entry.relativePath === 'string' &&
-            typeof entry.timestamp === 'string' &&
-            typeof entry.workspaceId === 'string');
-    }
-    catch (error) {
-        console.warn('[offline-queue] Could not read queue file, starting fresh');
-        return [];
-    }
-}
-/**
- * Persist the queue to disk atomically.
- */
-export function persistQueue(queue) {
-    const queuePath = getQueuePath();
-    const tempPath = `${queuePath}.tmp.${process.pid}`;
-    const content = JSON.stringify(queue, null, 2);
-    fs.writeFileSync(tempPath, content, { mode: 0o600 });
-    fs.renameSync(tempPath, queuePath);
-}
-/**
- * Add a change to the offline queue.
- * Deduplicates by keeping only the latest change per path/workspace combination.
- */
-export function queueChange(queue, change) {
-    // Find existing entry for same path and workspace
-    const existingIdx = queue.findIndex(c => c.relativePath === change.relativePath && c.workspaceId === change.workspaceId);
-    let newQueue;
-    if (existingIdx >= 0) {
-        // Replace existing entry with new one
-        newQueue = [...queue];
-        newQueue[existingIdx] = change;
-    }
-    else {
-        // Add new entry
-        newQueue = [...queue, change];
-    }
-    // Persist to disk
-    persistQueue(newQueue);
-    return newQueue;
-}
-/**
- * Remove a change from the queue after successful sync.
- */
-export function removeFromQueue(queue, change) {
-    const newQueue = queue.filter(c => !(c.relativePath === change.relativePath &&
-        c.workspaceId === change.workspaceId &&
-        c.timestamp === change.timestamp));
-    // Persist to disk
-    persistQueue(newQueue);
-    return newQueue;
-}
-/**
- * Sort queue by timestamp for ordered replay.
- */
-export function sortQueueByTimestamp(queue) {
-    return [...queue].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-}
-/**
- * Clear the entire queue.
- */
-export function clearQueue() {
-    const queuePath = getQueuePath();
-    if (fs.existsSync(queuePath)) {
-        fs.unlinkSync(queuePath);
-    }
-}
-/**
- * Get queue statistics.
- */
-export function getQueueStats(queue) {
-    const workspaceIds = new Set(queue.map(c => c.workspaceId));
-    return {
-        total: queue.length,
-        creates: queue.filter(c => c.type === 'create').length,
-        updates: queue.filter(c => c.type === 'update').length,
-        deletes: queue.filter(c => c.type === 'delete').length,
-        workspaces: workspaceIds.size,
-    };
-}
-// glassware[type="implementation", id="impl-offline-queue-manager--311f689d", requirements="requirement-cli-sync-offline-queue--08f04bd5,requirement-cli-sync-queue-replay--a7954975"]
-/**
- * OfflineQueueManager - manages the offline queue as a class for daemon use.
- */
-export class OfflineQueueManager {
-    constructor(logger = console.log) {
-        this.queue = [];
-        this.log = logger;
-        this.queue = loadQueue();
-        this.log(`[offline-queue] Loaded ${this.queue.length} queued changes`);
-    }
-    /**
-     * Add a change to the queue.
-     */
-    add(change) {
-        const timestampedChange = {
-            ...change,
-            timestamp: new Date().toISOString(),
-        };
-        this.queue = queueChange(this.queue, timestampedChange);
-        this.log(`[offline-queue] Queued ${change.type}: ${change.relativePath}`);
-    }
-    /**
-     * Get all queued changes, sorted by timestamp.
-     */
-    getAll() {
-        return sortQueueByTimestamp(this.queue);
-    }
-    /**
-     * Get changes for a specific workspace.
-     */
-    getForWorkspace(workspaceId) {
-        return sortQueueByTimestamp(this.queue.filter(c => c.workspaceId === workspaceId));
-    }
-    /**
-     * Mark a change as successfully synced (removes from queue).
-     */
-    markSynced(change) {
-        this.queue = removeFromQueue(this.queue, change);
-        this.log(`[offline-queue] Synced: ${change.relativePath}`);
-    }
-    /**
-     * Replay all queued changes using the provided sync function.
-     * @param syncFn - Function to sync each change
-     * @returns Number of successfully synced changes
-     */
-    async replay(syncFn) {
-        const sorted = this.getAll();
-        let synced = 0;
-        let failed = 0;
-        this.log(`[offline-queue] Replaying ${sorted.length} queued changes...`);
-        for (const change of sorted) {
-            try {
-                const success = await syncFn(change);
-                if (success) {
-                    this.markSynced(change);
-                    synced++;
-                }
-                else {
-                    failed++;
-                    this.log(`[offline-queue] Failed to sync: ${change.relativePath}`);
-                }
-            }
-            catch (error) {
-                failed++;
-                this.log(`[offline-queue] Error syncing ${change.relativePath}: ${error?.message || error}`);
-            }
-        }
-        this.log(`[offline-queue] Replay complete: ${synced} synced, ${failed} failed`);
-        return { synced, failed };
-    }
-    /**
-     * Get queue statistics.
-     */
-    getStats() {
-        return getQueueStats(this.queue);
-    }
-    /**
-     * Clear all queued changes.
-     */
-    clear() {
-        clearQueue();
-        this.queue = [];
-        this.log('[offline-queue] Queue cleared');
-    }
-    /**
-     * Check if queue has pending changes.
-     */
-    hasPending() {
-        return this.queue.length > 0;
-    }
-    /**
-     * Get count of pending changes.
-     */
-    getPendingCount() {
-        return this.queue.length;
-    }
-}

package/dist/daemon/path-utils.js

@@ -1,64 +0,0 @@
-// glassware[type="implementation", id="impl-path-utils--4ad8bb3f", requirements="requirement-cli-sync-path-normalize--5087578b"]
-/**
- * Path normalization utilities for cross-platform consistency.
- * Ensures all paths use forward slashes and are relative to workspace root.
- */
-import path from 'path';
-/**
- * Normalize a path to forward-slash format relative to workspace root.
- * @param absolutePath - Absolute path to the file
- * @param workspaceRoot - Absolute path to the workspace root directory
- * @returns Forward-slash separated relative path
- */
-export function normalizePath(absolutePath, workspaceRoot) {
-    const relative = path.relative(workspaceRoot, absolutePath);
-    return relative.split(path.sep).join('/');
-}
-/**
- * Get the parent directory path from a file path.
- * @param relativePath - Forward-slash separated relative path
- * @returns Parent directory path, or null if file is at root
- */
-export function getParentPath(relativePath) {
-    const parts = relativePath.split('/');
-    parts.pop(); // Remove filename
-    return parts.length > 0 ? parts.join('/') : null;
-}
-/**
- * Get the filename from a path.
- * @param filePath - Forward-slash separated path
- * @returns Filename
- */
-export function getFileName(filePath) {
-    return filePath.split('/').pop() || filePath;
-}
-/**
- * Get directory parts from a file path (excluding filename).
- * @param relativePath - Forward-slash separated relative path
- * @returns Array of directory names
- */
-export function getDirectoryParts(relativePath) {
-    const parts = relativePath.split('/');
-    parts.pop(); // Remove filename
-    return parts;
-}
-/**
- * Join path parts with forward slashes.
- * @param parts - Path parts to join
- * @returns Forward-slash separated path
- */
-export function joinPath(...parts) {
-    return parts.filter(Boolean).join('/');
-}
-/**
- * Check if a path is within the workspace root.
- * Prevents path traversal attacks.
- * @param absolutePath - Absolute path to check
- * @param workspaceRoot - Workspace root directory
- * @returns true if path is within workspace
- */
-export function isWithinWorkspace(absolutePath, workspaceRoot) {
-    const resolvedPath = path.resolve(absolutePath);
-    const resolvedRoot = path.resolve(workspaceRoot);
-    return resolvedPath.startsWith(resolvedRoot + path.sep) || resolvedPath === resolvedRoot;
-}