@mod-computer/cli 0.1.0

package/dist/daemon-worker.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import chokidar from 'chokidar';
+import { AutomaticFileTracker } from './services/automatic-file-tracker.js';
+import { createModWorkspace } from '@mod/mod-core';
+import { repo as getRepo } from '@mod/mod-core/repos/repo.node';
+import { readModConfig } from './services/mod-config.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+class DaemonWorker {
+    constructor(options) {
+        this.isShuttingDown = false;
+        this.options = options;
+        this.stateFilePath = path.join(options.workingDir, '.mod', '.cache', 'sync-daemon.json');
+    }
+    async start() {
+        try {
+            process.on('SIGTERM', () => this.gracefulShutdown());
+            process.on('SIGINT', () => this.gracefulShutdown());
+            process.on('uncaughtException', (error) => this.handleError(error));
+            process.on('unhandledRejection', (error) => this.handleError(error));
+            await this.updateState({
+                status: 'running',
+                lastActivity: new Date().toISOString(),
+                watchedFiles: 0
+            });
+            if (this.options.verbose) {
+                console.log(`🚀 Daemon worker starting...`);
+                console.log(`📁 Working directory: ${this.options.workingDir}`);
+                console.log(`🔗 Workspace ID: ${this.options.workspaceId}`);
+                console.log(`🌿 Active branch: ${this.options.activeBranchId}`);
+            }
+            // Initialize repo and workspace (this would need proper repo setup)
+            // For now, using placeholder implementation
+            const repo = await this.initializeRepo();
+            const modWorkspace = createModWorkspace(repo);
+            const workspaceHandles = await modWorkspace.listWorkspaces();
+            this.workspaceHandle = workspaceHandles.find(wh => wh.id === this.options.workspaceId);
+            if (!this.workspaceHandle) {
+                throw new Error(`Workspace ${this.options.workspaceId} not found`);
+            }
+            // Set active branch
+            if (this.options.activeBranchId) {
+                try {
+                    await this.workspaceHandle.branch.switchActive(this.options.activeBranchId);
+                }
+                catch (error) {
+                    console.warn(`⚠️  Failed to set active branch: ${error}`);
+                }
+            }
+            await this.setupConfigWatcher();
+            this.tracker = new AutomaticFileTracker(repo);
+            await this.tracker.enableAutoTracking({
+                workspaceId: this.options.workspaceId,
+                workspaceHandle: this.workspaceHandle,
+                watchDirectory: this.options.workingDir,
+                debounceMs: 500,
+                verbose: this.options.verbose || false,
+                maxWatchedFiles: 2000,
+                preFilterEnabled: true,
+                comprehensiveMode: true,
+                resourceMonitoring: true
+            });
+            const status = this.tracker.getTrackingStatus();
+            await this.updateState({
+                watchedFiles: status.watchedFiles,
+                lastActivity: new Date().toISOString()
+            });
+            if (this.options.verbose) {
+                console.log(`✅ Daemon worker running (PID: ${process.pid})`);
+                console.log(`📊 Watching ${status.watchedFiles} files`);
+            }
+            await this.keepAlive();
+        }
+        catch (error) {
+            await this.handleError(error);
+            process.exit(1);
+        }
+    }
+    async gracefulShutdown() {
+        if (this.isShuttingDown)
+            return;
+        this.isShuttingDown = true;
+        console.log('\n🛑 Daemon worker shutting down...');
+        try {
+            await this.updateState({
+                status: 'stopping',
+                lastActivity: new Date().toISOString()
+            });
+            if (this.tracker) {
+                await this.tracker.disableAutoTracking();
+            }
+            if (this.configWatcher) {
+                await this.configWatcher.close();
+            }
+            await this.updateState({
+                status: 'stopped',
+                lastActivity: new Date().toISOString()
+            });
+            console.log('✅ Daemon worker stopped gracefully');
+            process.exit(0);
+        }
+        catch (error) {
+            console.error('Error during graceful shutdown:', error);
+            process.exit(1);
+        }
+    }
+    async handleError(error) {
+        console.error('💥 Daemon worker error:', error);
+        try {
+            await this.updateState({
+                status: 'crashed',
+                lastError: error.message || 'Unknown error',
+                lastActivity: new Date().toISOString()
+            });
+        }
+        catch (stateError) {
+            console.error('Failed to update error state:', stateError);
+        }
+        // Let the main daemon handle restart logic
+        process.exit(1);
+    }
+    async keepAlive() {
+        while (!this.isShuttingDown) {
+            try {
+                await this.updateState({
+                    lastActivity: new Date().toISOString()
+                });
+                // Check if tracking is still active
+                if (this.tracker) {
+                    const status = this.tracker.getTrackingStatus();
+                    if (status.watchedFiles !== undefined) {
+                        await this.updateState({ watchedFiles: status.watchedFiles });
+                    }
+                }
+                await new Promise(resolve => setTimeout(resolve, 10000)); // 10 second intervals
+            }
+            catch (error) {
+                await this.handleError(error);
+                break;
+            }
+        }
+    }
+    async updateState(updates) {
+        try {
+            let currentState = {};
+            try {
+                const data = await fs.readFile(this.stateFilePath, 'utf8');
+                currentState = JSON.parse(data);
+            }
+            catch { /* State file doesn't exist yet */ }
+            const newState = { ...currentState, ...updates, pid: process.pid };
+            await fs.writeFile(this.stateFilePath, JSON.stringify(newState, null, 2), 'utf8');
+        }
+        catch (error) {
+            console.error('Failed to update daemon state:', error);
+        }
+    }
+    async setupConfigWatcher() {
+        const configPath = path.join(this.options.workingDir, '.mod', 'config.json');
+        this.configWatcher = chokidar.watch(configPath, {
+            persistent: true,
+            ignoreInitial: true
+        });
+        this.configWatcher.on('change', async () => {
+            try {
+                await this.handleConfigChange();
+            }
+            catch (error) {
+                console.error('Error handling config change:', error);
+            }
+        });
+        if (this.options.verbose) {
+            console.log(`🔍 Watching config file: ${configPath}`);
+        }
+    }
+    async handleConfigChange() {
+        try {
+            // Read the updated config
+            const config = readModConfig();
+            if (!config?.activeBranchId) {
+                return;
+            }
+            // Check if the branch has actually changed
+            if (config.activeBranchId === this.options.activeBranchId) {
+                return;
+            }
+            if (this.options.verbose) {
+                console.log(`🔄 Branch switch detected: ${this.options.activeBranchId} → ${config.activeBranchId}`);
+            }
+            if (this.workspaceHandle) {
+                try {
+                    await this.workspaceHandle.branch.switchActive(config.activeBranchId);
+                    this.options.activeBranchId = config.activeBranchId;
+                    await this.updateState({
+                        activeBranchId: config.activeBranchId,
+                        lastActivity: new Date().toISOString()
+                    });
+                    if (this.options.verbose) {
+                        console.log(`✅ Switched to branch: ${config.activeBranchId}`);
+                    }
+                }
+                catch (error) {
+                    console.error(`❌ Failed to switch to branch ${config.activeBranchId}:`, error);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error reading config during branch switch:', error);
+        }
+    }
+    async initializeRepo() {
+        // Use the same repo initialization as the main CLI
+        return await getRepo();
+    }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const args = process.argv.slice(2);
+    const options = {
+        workspaceId: '',
+        activeBranchId: 'main',
+        workingDir: process.cwd(),
+        verbose: false
+    };
+    // Parse command line arguments
+    for (let i = 0; i < args.length; i += 2) {
+        const key = args[i];
+        const value = args[i + 1];
+        switch (key) {
+            case '--workspace-id':
+                options.workspaceId = value;
+                break;
+            case '--active-branch':
+                options.activeBranchId = value;
+                break;
+            case '--working-dir':
+                options.workingDir = value;
+                break;
+            case '--verbose':
+                options.verbose = true;
+                i--; // No value for this flag
+                break;
+        }
+    }
+    if (!options.workspaceId) {
+        console.error('❌ Workspace ID is required');
+        process.exit(1);
+    }
+    const worker = new DaemonWorker(options);
+    worker.start().catch((error) => {
+        console.error('❌ Failed to start daemon worker:', error);
+        process.exit(1);
+    });
+}
+export { DaemonWorker };

package/dist/lib/auth-server.js

@@ -0,0 +1,153 @@
+// glassware[type=implementation, id=cli-auth-server, requirements=req-cli-auth-app-2,req-cli-auth-app-4,req-cli-auth-qual-1]
+import http from 'http';
+import { URL } from 'url';
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * Start a localhost HTTP server to receive OAuth callback.
+ * Returns the port number and a promise that resolves with auth result.
+ */
+export async function startAuthServer(options = {}) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    let resolveAuth;
+    let rejectAuth;
+    const resultPromise = new Promise((resolve, reject) => {
+        resolveAuth = resolve;
+        rejectAuth = reject;
+    });
+    const server = http.createServer((req, res) => {
+        const url = new URL(req.url || '/', `http://localhost`);
+        if (url.pathname === '/callback') {
+            const token = url.searchParams.get('token');
+            const email = url.searchParams.get('email');
+            const name = url.searchParams.get('name');
+            const googleId = url.searchParams.get('googleId');
+            if (token && email && googleId) {
+                // Send success page to browser
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(getSuccessPage(name || email));
+                // Resolve with auth result
+                resolveAuth({
+                    googleIdToken: token,
+                    googleId,
+                    email,
+                    name: name || email.split('@')[0],
+                });
+            }
+            else {
+                // Missing parameters
+                res.writeHead(400, { 'Content-Type': 'text/html' });
+                res.end(getErrorPage('Missing authentication parameters'));
+                rejectAuth(new Error('Missing authentication parameters in callback'));
+            }
+        }
+        else {
+            res.writeHead(404, { 'Content-Type': 'text/plain' });
+            res.end('Not found');
+        }
+    });
+    // Wait for server to start listening
+    const port = await new Promise((resolve, reject) => {
+        server.on('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : 0;
+            resolve(port);
+        });
+    });
+    // Set timeout
+    const timeoutId = setTimeout(() => {
+        server.close();
+        rejectAuth(new Error('Authentication timed out after 5 minutes'));
+    }, timeoutMs);
+    // Close server when auth completes
+    resultPromise.finally(() => {
+        clearTimeout(timeoutId);
+        server.close();
+    });
+    return {
+        port,
+        result: resultPromise,
+        close: () => {
+            clearTimeout(timeoutId);
+            server.close();
+            rejectAuth(new Error('Authentication cancelled'));
+        },
+    };
+}
+function getSuccessPage(name) {
+    return `<!DOCTYPE html>
+<html>
+<head>
+  <title>Signed in to Mod</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      color: white;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+      background: rgba(255,255,255,0.1);
+      border-radius: 12px;
+      backdrop-filter: blur(10px);
+    }
+    h1 { margin-bottom: 0.5rem; }
+    p { opacity: 0.9; }
+    .check { font-size: 3rem; margin-bottom: 1rem; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="check">✓</div>
+    <h1>Welcome, ${escapeHtml(name)}!</h1>
+    <p>You can close this window and return to your terminal.</p>
+  </div>
+</body>
+</html>`;
+}
+function getErrorPage(message) {
+    return `<!DOCTYPE html>
+<html>
+<head>
+  <title>Authentication Error</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      height: 100vh;
+      margin: 0;
+      background: #1a1a2e;
+      color: white;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+    }
+    h1 { color: #ff6b6b; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Authentication Error</h1>
+    <p>${escapeHtml(message)}</p>
+    <p>Please try again from your terminal.</p>
+  </div>
+</body>
+</html>`;
+}
+function escapeHtml(str) {
+    return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+}

package/dist/lib/browser.js

@@ -0,0 +1,35 @@
+// glassware[type=implementation, id=cli-browser-opener, requirements=req-cli-auth-ux-2,req-cli-auth-ux-4]
+import { exec } from 'child_process';
+import { platform } from 'os';
+/**
+ * Open a URL in the default browser.
+ * Returns true if successful, false if browser couldn't be opened.
+ */
+export async function openBrowser(url) {
+    const command = getBrowserCommand(url);
+    return new Promise((resolve) => {
+        exec(command, (error) => {
+            if (error) {
+                resolve(false);
+            }
+            else {
+                resolve(true);
+            }
+        });
+    });
+}
+/**
+ * Get the platform-specific command to open a URL.
+ */
+function getBrowserCommand(url) {
+    const escapedUrl = url.replace(/"/g, '\\"');
+    switch (platform()) {
+        case 'darwin':
+            return `open "${escapedUrl}"`;
+        case 'win32':
+            return `start "" "${escapedUrl}"`;
+        default:
+            // Linux and others - try xdg-open
+            return `xdg-open "${escapedUrl}"`;
+    }
+}

package/dist/lib/storage.js

@@ -0,0 +1,203 @@
+// glassware[type=implementation, id=cli-storage-utils, requirements=req-cli-storage-struct-1,req-cli-storage-app-1,req-cli-storage-app-2,req-cli-storage-app-3,req-cli-storage-conn-2,req-cli-storage-qual-1,req-cli-storage-qual-5]
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import os from 'os';
+import { DEFAULT_CONFIG, DEFAULT_SETTINGS } from '../types/config.js';
+/**
+ * Get the path to the ~/.mod/ directory.
+ */
+export function getModDir() {
+    return path.join(os.homedir(), '.mod');
+}
+/**
+ * Ensure the ~/.mod/ directory structure exists.
+ * Creates: ~/.mod/, ~/.mod/workspaces/, ~/.mod/automerge/, ~/.mod/logs/
+ */
+export function ensureModDir() {
+    const modDir = getModDir();
+    const dirs = [
+        modDir,
+        path.join(modDir, 'workspaces'),
+        path.join(modDir, 'automerge'),
+        path.join(modDir, 'logs'),
+    ];
+    for (const dir of dirs) {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        }
+    }
+}
+/**
+ * Get the path to the config file.
+ */
+export function getConfigPath() {
+    return path.join(getModDir(), 'config');
+}
+/**
+ * Read the global config from ~/.mod/config.
+ * Returns default config if file doesn't exist or is invalid.
+ */
+export function readConfig() {
+    const configPath = getConfigPath();
+    if (!fs.existsSync(configPath)) {
+        return { ...DEFAULT_CONFIG };
+    }
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const stored = JSON.parse(content);
+        // Merge with defaults for missing fields
+        return {
+            version: stored.version ?? DEFAULT_CONFIG.version,
+            auth: stored.auth ?? null,
+            settings: {
+                ...DEFAULT_SETTINGS,
+                ...stored.settings,
+            },
+        };
+    }
+    catch (error) {
+        // Return defaults if file is corrupted
+        console.warn('Warning: Could not read ~/.mod/config, using defaults');
+        return { ...DEFAULT_CONFIG };
+    }
+}
+/**
+ * Write config to ~/.mod/config atomically.
+ * Creates the file with 0600 permissions (user read/write only).
+ */
+export function writeConfig(config) {
+    ensureModDir();
+    const configPath = getConfigPath();
+    atomicWrite(configPath, JSON.stringify(config, null, 2), 0o600);
+}
+/**
+ * Get the path to a workspace connection file for a directory.
+ * Uses SHA-256 hash of the absolute path (first 16 chars).
+ */
+export function getWorkspaceConnectionPath(directoryPath) {
+    const absolutePath = path.resolve(directoryPath);
+    const hash = crypto
+        .createHash('sha256')
+        .update(absolutePath)
+        .digest('hex')
+        .slice(0, 16);
+    return path.join(getModDir(), 'workspaces', hash);
+}
+/**
+ * Read the workspace connection for a directory.
+ * Returns null if no connection exists.
+ */
+export function readWorkspaceConnection(directoryPath) {
+    const connectionPath = getWorkspaceConnectionPath(directoryPath);
+    if (!fs.existsSync(connectionPath)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(connectionPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        console.warn(`Warning: Could not read workspace connection for ${directoryPath}`);
+        return null;
+    }
+}
+/**
+ * Write a workspace connection for a directory atomically.
+ */
+export function writeWorkspaceConnection(directoryPath, connection) {
+    ensureModDir();
+    const connectionPath = getWorkspaceConnectionPath(directoryPath);
+    atomicWrite(connectionPath, JSON.stringify(connection, null, 2), 0o600);
+}
+/**
+ * Delete the workspace connection for a directory.
+ */
+export function deleteWorkspaceConnection(directoryPath) {
+    const connectionPath = getWorkspaceConnectionPath(directoryPath);
+    if (!fs.existsSync(connectionPath)) {
+        return false;
+    }
+    try {
+        fs.unlinkSync(connectionPath);
+        return true;
+    }
+    catch (error) {
+        console.warn(`Warning: Could not delete workspace connection for ${directoryPath}`);
+        return false;
+    }
+}
+/**
+ * List all workspace connections.
+ * Returns array of connections, filtering out corrupted files.
+ */
+export function listWorkspaceConnections() {
+    const workspacesDir = path.join(getModDir(), 'workspaces');
+    if (!fs.existsSync(workspacesDir)) {
+        return [];
+    }
+    const files = fs.readdirSync(workspacesDir);
+    const connections = [];
+    for (const file of files) {
+        const filePath = path.join(workspacesDir, file);
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const connection = JSON.parse(content);
+            connections.push(connection);
+        }
+        catch (error) {
+            // Skip corrupted files
+            continue;
+        }
+    }
+    return connections;
+}
+/**
+ * Find workspace connection for the current directory or any parent.
+ * Walks up the directory tree looking for a connection.
+ */
+export function findWorkspaceConnection(startPath) {
+    let currentPath = path.resolve(startPath);
+    const root = path.parse(currentPath).root;
+    while (currentPath !== root) {
+        const connection = readWorkspaceConnection(currentPath);
+        if (connection) {
+            return connection;
+        }
+        currentPath = path.dirname(currentPath);
+    }
+    return null;
+}
+/**
+ * Atomic write: write to temp file then rename.
+ * Ensures file is never partially written.
+ */
+function atomicWrite(filePath, content, mode) {
+    const tempPath = `${filePath}.tmp.${process.pid}`;
+    fs.writeFileSync(tempPath, content, { mode });
+    fs.renameSync(tempPath, filePath);
+}
+/**
+ * Get the path to the sync daemon PID file.
+ */
+export function getPidFilePath() {
+    return path.join(getModDir(), 'sync.pid');
+}
+/**
+ * Get the path to the automerge storage directory.
+ */
+export function getAutomergeStoragePath() {
+    return path.join(getModDir(), 'automerge');
+}
+/**
+ * Get the path to the logs directory.
+ */
+export function getLogsDir() {
+    return path.join(getModDir(), 'logs');
+}
+/**
+ * Get the path to the sync daemon log file.
+ */
+export function getSyncLogPath() {
+    return path.join(getLogsDir(), 'sync.log');
+}