@mod-computer/cli 0.1.1 → 0.2.2

package/dist/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --disable-warning=ExperimentalWarning
 import { jsx as _jsx } from "react/jsx-runtime";
 import dotenv from 'dotenv';
 import path from 'path';
@@ -75,29 +75,40 @@ const cli = meow(`
         force: {
             type: 'boolean',
             default: false
+        },
+        dev: {
+            type: 'boolean',
+            default: false
+        },
+        json: {
+            type: 'boolean',
+            default: false
         }
     },
     allowUnknownFlags: true
 });
 async function main() {
     const repo = await getRepo();
+    // Load user document into share policy if logged in
+    const { readConfig } = await import('./lib/storage.js');
+    const { addUserToSharePolicy } = await import('./daemon/share-policy.js');
+    const config = readConfig();
+    if (config.auth?.userDocId) {
+        addUserToSharePolicy(config.auth.userDocId);
+    }
     const availableCommands = buildCommandRegistry();
     const [cmd, ...args] = cli.input;
     // No user-facing banners or notifications about feature flags
     // Background watch now handled by automatic-file-tracker service
     // Handle command execution
     if (cmd && typeof availableCommands[cmd] === 'function') {
-        // Pass both positional args and flags as a combined array
-        const allArgs = [...args];
-        // Add flags back to args array for backward compatibility
-        if (cli.flags.preview)
-            allArgs.push('--preview');
-        if (cli.flags.verbose)
-            allArgs.push('--verbose');
-        if (cli.flags.force)
-            allArgs.push('--force');
-        await availableCommands[cmd](allArgs, repo);
-        return;
+        // Pass raw args after the command name from process.argv
+        // This preserves all flags (--type, --file, --json, etc.) as-is
+        const cmdIndex = process.argv.findIndex(arg => arg === cmd);
+        const rawArgs = cmdIndex >= 0 ? process.argv.slice(cmdIndex + 1) : args;
+        await availableCommands[cmd](rawArgs, repo);
+        // Exit after command completes - WebSocket keeps event loop alive otherwise
+        process.exit(0);
     }
     if (!cmd) {
         console.log('Mod CLI\n');

package/dist/commands/add.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+// glassware[type="implementation", id="impl-cli-add-command--777b18e2", requirements="requirement-cli-add-cmd--aff0d740,requirement-cli-add-cmd-help--e0709244,requirement-cli-add-progress-small--5474ba10,requirement-cli-add-progress-medium--0f22e3e8,requirement-cli-add-progress-large--477f1e9a,requirement-cli-add-summary--3d0fb9b5,requirement-cli-add-dry-run--91bb0ff6,requirement-cli-add-verbose--3a958508"]
+// spec: packages/mod-cli/specs/add.md
+import ora from 'ora';
+import { AddService } from '../services/add-service.js';
+import { validateAddOptions, validateWorkspaceState } from '../services/add-validation.js';
+import { ADD_CONSTANTS, } from '../types/add-types.js';
+/**
+ * Parse command line arguments
+ */
+function parseArgs(args) {
+    const paths = [];
+    let dryRun = false;
+    let includeLargeBinary = false;
+    let verbose = false;
+    let quiet = false;
+    for (const arg of args) {
+        if (arg === '--dry-run') {
+            dryRun = true;
+        }
+        else if (arg === '--include-large-binary') {
+            includeLargeBinary = true;
+        }
+        else if (arg === '-v' || arg === '--verbose') {
+            verbose = true;
+        }
+        else if (arg === '-q' || arg === '--quiet') {
+            quiet = true;
+        }
+        else if (!arg.startsWith('-')) {
+            paths.push(arg);
+        }
+    }
+    // Default to current directory if no paths
+    if (paths.length === 0) {
+        paths.push('.');
+    }
+    return { paths, dryRun, includeLargeBinary, verbose, quiet };
+}
+/**
+ * Add command entry point
+ */
+export async function addCommand(args, repo) {
+    // Parse arguments
+    const { paths, dryRun, includeLargeBinary, verbose, quiet } = parseArgs(args);
+    const options = {
+        paths,
+        dryRun,
+        includeLargeBinary,
+        verbose,
+        quiet
+    };
+    // Validate options
+    const optionsValidation = validateAddOptions(options);
+    if (!optionsValidation.valid) {
+        for (const error of optionsValidation.errors) {
+            console.error(`Error: ${error.message}`);
+        }
+        process.exit(1);
+    }
+    // Validate workspace
+    const workspaceValidation = await validateWorkspaceState(process.cwd());
+    if (!workspaceValidation.valid) {
+        for (const error of workspaceValidation.errors) {
+            console.error(`Error: ${error.message}`);
+        }
+        process.exit(1);
+    }
+    // Create add service
+    const addService = new AddService(repo);
+    // Set up cancellation handler
+    process.on('SIGINT', () => {
+        addService.cancel();
+        console.log('\nCancelling...');
+    });
+    // Progress tracking
+    let spinner = null;
+    let lastProgressUpdate = 0;
+    const progressBarWidth = 30;
+    const onProgress = (progress) => {
+        if (quiet)
+            return;
+        // Throttle progress updates (cli-add-progress-throttle)
+        const now = Date.now();
+        if (now - lastProgressUpdate < ADD_CONSTANTS.PROGRESS_THROTTLE_MS)
+            return;
+        lastProgressUpdate = now;
+        if (progress.phase === 'scanning') {
+            if (!spinner) {
+                spinner = ora('Scanning...').start();
+            }
+            spinner.text = `Scanning... ${progress.total} files found`;
+        }
+        else if (progress.phase === 'comparing') {
+            if (spinner) {
+                spinner.text = `Comparing... ${progress.current}/${progress.total} directories`;
+            }
+        }
+        else if (progress.phase === 'adding') {
+            const total = progress.total;
+            if (total < ADD_CONSTANTS.SMALL_ADD_THRESHOLD) {
+                // Small: no progress bar
+                if (spinner) {
+                    spinner.text = `Adding... ${progress.current}/${total}`;
+                }
+            }
+            else if (total < ADD_CONSTANTS.MEDIUM_ADD_THRESHOLD) {
+                // Medium: spinner with count
+                if (spinner) {
+                    spinner.text = `Adding... ${progress.current}/${total} files`;
+                }
+            }
+            else {
+                // Large: progress bar
+                const percent = Math.round((progress.current / total) * 100);
+                const filled = Math.round((progress.current / total) * progressBarWidth);
+                const bar = '█'.repeat(filled) + '░'.repeat(progressBarWidth - filled);
+                const eta = progress.eta ? ` | ETA: ${formatEta(progress.eta)}` : '';
+                if (spinner) {
+                    spinner.text = `Adding files...\n[${bar}] ${percent}% | ${progress.current.toLocaleString()}/${total.toLocaleString()}${eta}`;
+                }
+            }
+            if (verbose && progress.currentFile) {
+                console.log(`+ ${progress.currentFile}`);
+            }
+        }
+    };
+    // Execute
+    try {
+        const result = await addService.execute(options, onProgress);
+        // Stop spinner
+        if (spinner) {
+            spinner.stop();
+        }
+        // Print result
+        printResult(result, options);
+        if (!result.success) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        if (spinner) {
+            spinner.stop();
+        }
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}
+/**
+ * Print the result of the add operation
+ */
+function printResult(result, options) {
+    const { summary, directories, duration } = result;
+    if (options.dryRun) {
+        // Dry run output
+        console.log(`Would add ${summary.totalFiles.toLocaleString()} files across ${directories.length} directories:`);
+        for (const dir of directories.slice(0, 10)) {
+            console.log(`  ${dir.path}/ (${dir.created} files)`);
+        }
+        if (directories.length > 10) {
+            console.log(`  ... (${directories.length - 10} more directories)`);
+        }
+        if (summary.skipped > 0) {
+            console.log(`\nWould skip ${summary.skipped} files`);
+        }
+        const estimatedMinutes = Math.ceil(summary.totalFiles * 50 / 1000 / 60);
+        console.log(`\nEstimated time: ~${estimatedMinutes} minutes`);
+        return;
+    }
+    // Normal output
+    if (options.quiet) {
+        // Quiet: only show summary line
+        if (summary.errors > 0) {
+            console.log(`Added ${summary.created} files (${summary.errors} errors)`);
+        }
+        else {
+            console.log(`Added ${summary.created} files`);
+        }
+        return;
+    }
+    // Standard output
+    const parts = [];
+    if (summary.created > 0) {
+        parts.push(`${summary.created} created`);
+    }
+    if (summary.updated > 0) {
+        parts.push(`${summary.updated} updated`);
+    }
+    if (summary.unchanged > 0) {
+        parts.push(`${summary.unchanged} unchanged`);
+    }
+    if (parts.length > 0) {
+        console.log(`\nAdded ${summary.totalFiles.toLocaleString()} files (${parts.join(', ')})`);
+    }
+    else {
+        console.log(`\nNo files to add`);
+    }
+    // Show skipped files
+    if (summary.skipped > 0) {
+        console.log(`\nSkipped: ${summary.skipped} files`);
+    }
+    // Show errors
+    if (summary.errors > 0) {
+        console.log(`\nErrors: ${summary.errors} files`);
+        // Show first few errors
+        const allErrors = directories.flatMap(d => d.errors);
+        for (const error of allErrors.slice(0, 5)) {
+            console.log(`  ${error.relativePath}: ${error.error?.message}`);
+        }
+        if (allErrors.length > 5) {
+            console.log(`  ... (${allErrors.length - 5} more errors)`);
+        }
+    }
+    // Show duration
+    console.log(`\nCompleted in ${formatDuration(duration)}`);
+}
+/**
+ * Format duration in human readable format
+ */
+function formatDuration(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
+    }
+    if (ms < 60000) {
+        return `${(ms / 1000).toFixed(1)}s`;
+    }
+    const minutes = Math.floor(ms / 60000);
+    const seconds = Math.round((ms % 60000) / 1000);
+    return `${minutes}m ${seconds}s`;
+}
+/**
+ * Format ETA in human readable format
+ */
+function formatEta(ms) {
+    if (ms < 60000) {
+        return `${Math.round(ms / 1000)}s`;
+    }
+    const minutes = Math.floor(ms / 60000);
+    const seconds = Math.round((ms % 60000) / 1000);
+    if (seconds === 0) {
+        return `${minutes}m`;
+    }
+    return `${minutes}m ${seconds}s`;
+}
+export default addCommand;

package/dist/commands/auth.js

@@ -1,15 +1,17 @@
-// glassware[type=implementation, id=cli-auth-command, requirements=req-cli-auth-ux-2,req-cli-auth-ux-3,req-cli-auth-ux-4,req-cli-auth-ux-5,req-cli-auth-ux-6,req-cli-auth-app-1,req-cli-auth-app-5]
+// glassware[type="implementation", id="impl-cli-auth-command--649dd0cd", specifications="specification-spec-auth-login--c8f45e62,specification-spec-auth-status--36efb6a8,specification-spec-auth-logout--79cb4081"]
 import { readConfig, writeConfig } from '../lib/storage.js';
 import { openBrowser } from '../lib/browser.js';
 import { startAuthServer } from '../lib/auth-server.js';
-// Auth server base URL - configurable via environment variable
-const AUTH_BASE_URL = process.env.MOD_AUTH_URL || 'https://auth.mod.app';
-const API_BASE_URL = process.env.MOD_API_URL || 'https://api.mod.app';
+import { createModUser } from '@mod/mod-core';
+import { addUserToSharePolicy } from '../daemon/share-policy.js';
+// Auth worker URL - configurable via environment variable
+// Uses the Cloudflare Worker for OAuth
+const AUTH_WORKER_URL = process.env.MOD_AUTH_URL || 'https://mod-auth-worker.mod-workers.workers.dev';
 export async function authCommand(args, repo) {
-    const [subcommand] = args;
+    const [subcommand, ...rest] = args;
     switch (subcommand) {
         case 'login':
-            await handleLogin();
+            await handleLogin(rest, repo);
             break;
         case 'logout':
             await handleLogout();
@@ -24,15 +26,18 @@ export async function authCommand(args, repo) {
             else {
                 console.error('Usage: mod auth <login|logout|status>');
                 console.error('Available commands:');
-                console.error('  login     Sign in with Google OAuth');
-                console.error('  logout    Sign out and clear credentials');
-                console.error('  status    Show current authentication state');
+                console.error('  login [--dev]  Sign in with Google OAuth (or use --dev for local testing)');
+                console.error('  logout         Sign out and clear credentials');
+                console.error('  status         Show current authentication state');
                 process.exit(1);
             }
     }
     process.exit(0);
 }
-async function handleLogin() {
+// glassware[type="implementation", id="impl-handle-login--58bdb73b", specifications="specification-spec-auth-login--c8f45e62,specification-spec-open-browser--397b6a28,specification-spec-manual-url--b37b2760,specification-spec-validate-token--d3856b2d,specification-spec-success-message--b3bb1875,specification-spec-create-user-doc--282489ae,specification-spec-register-user-doc--e611f1db"]
+async function handleLogin(args = [], repo) {
+    // Check for --dev flag
+    const isDev = args.includes('--dev');
     // Check if already authenticated
     const config = readConfig();
     if (config.auth) {
@@ -41,10 +46,15 @@ async function handleLogin() {
         console.log('Run `mod auth logout` to sign out first.');
         return;
     }
+    // Dev mode: create local user without OAuth
+    if (isDev) {
+        await handleDevLogin(repo);
+        return;
+    }
     // Start localhost server to receive callback
     const { port, result, close } = await startAuthServer();
     // Build auth URL with callback port
-    const authUrl = `${AUTH_BASE_URL}/cli?port=${port}`;
+    const authUrl = `${AUTH_WORKER_URL}/auth/cli?port=${port}`;
     console.log('Opening browser to sign in...');
     // Try to open browser
     const opened = await openBrowser(authUrl);
@@ -58,19 +68,45 @@ async function handleLogin() {
     try {
         // Wait for auth callback
         const authResult = await result;
-        // Validate token with server (optional - server may not be available)
+        // Validate token with server and get existing userDocId
         let userDocId;
+        let authUserId;
         try {
-            userDocId = await validateAndGetUserDocId(authResult.googleIdToken);
+            const authProfile = await validateAndGetAuthProfile(authResult.googleIdToken);
+            userDocId = authProfile.userDocId;
+            authUserId = authProfile.userId;
         }
         catch (error) {
-            // If validation fails, continue without userDocId
-            // It will be set on first sync
+            // If validation fails, continue - we'll create user doc below
+        }
+        // If no userDocId (new user), create user document and register with server
+        if (!userDocId) {
+            try {
+                const modUser = createModUser(repo);
+                const userDoc = await modUser.findOrCreate({
+                    email: authResult.email,
+                    name: authResult.name,
+                    googleId: authResult.googleId,
+                    avatar: null,
+                });
+                userDocId = userDoc.id;
+                // Register the new userDocId with auth worker
+                await registerUserDoc(authResult.googleIdToken, userDocId);
+            }
+            catch (error) {
+                console.warn('Could not create/register user document:', error);
+                // Continue without userDocId - it can be set up later
+            }
+        }
+        // Add user doc to share policy if available
+        if (userDocId) {
+            addUserToSharePolicy(userDocId);
         }
         // Store credentials in config
         const updatedConfig = readConfig();
         updatedConfig.auth = {
             googleIdToken: authResult.googleIdToken,
+            userId: authUserId || '',
             googleId: authResult.googleId,
             email: authResult.email,
             name: authResult.name,
@@ -98,6 +134,7 @@ async function handleLogin() {
         process.exit(1);
     }
 }
+// glassware[type="implementation", id="impl-handle-logout--1f8e80ea", specifications="specification-spec-auth-logout--79cb4081,specification-spec-logout-message--2785cc24"]
 async function handleLogout() {
     const config = readConfig();
     if (!config.auth) {
@@ -111,6 +148,7 @@ async function handleLogout() {
     console.log('Signed out successfully');
     console.log(`Removed credentials for ${email}`);
 }
+// glassware[type="implementation", id="impl-handle-status--b14ce725", specifications="specification-spec-auth-status--36efb6a8,specification-spec-status-output--b8935802"]
 async function handleStatus() {
     const config = readConfig();
     if (!config.auth) {
@@ -126,19 +164,20 @@ async function handleStatus() {
     console.log('Token expires: never');
     // Check if token is still valid (optional)
     try {
-        await validateAndGetUserDocId(config.auth.googleIdToken);
+        await validateAndGetAuthProfile(config.auth.googleIdToken);
         console.log('Token status: valid');
     }
     catch (error) {
         console.log('Token status: could not verify (server unavailable)');
     }
 }
+// glassware[type="implementation", id="impl-validate-token--562d976d", specifications="specification-spec-validate-token--d3856b2d,specification-spec-load-user-doc--c7a835b0,specification-spec-auth-user-id--de3afa93"]
 /**
- * Validate token with server and get user document ID.
- * Returns existing userDocId for returning users, or undefined for new users.
+ * Validate token with server and get auth profile.
+ * Returns existing userDocId for returning users, or empty string for new users.
  */
-async function validateAndGetUserDocId(token) {
-    const response = await fetch(`${API_BASE_URL}/auth/me`, {
+async function validateAndGetAuthProfile(token) {
+    const response = await fetch(`${AUTH_WORKER_URL}/auth/me`, {
         headers: {
             Authorization: `Bearer ${token}`,
         },
@@ -147,5 +186,74 @@ async function validateAndGetUserDocId(token) {
         throw new Error('Token validation failed');
     }
     const data = (await response.json());
-    return data.userDocId;
+    return {
+        userId: data.id || '',
+        userDocId: data.userDocId || '',
+    };
+}
+export async function fetchAuthProfile(token) {
+    return validateAndGetAuthProfile(token);
+}
+// glassware[type="implementation", id="impl-register-user-doc--c699a7d3", specifications="specification-spec-register-user-doc--e611f1db"]
+/**
+ * Register a new userDocId with the auth worker.
+ * Called for new users after creating their Automerge user document.
+ */
+async function registerUserDoc(token, userDocId) {
+    const response = await fetch(`${AUTH_WORKER_URL}/auth/register-doc`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ userDocId }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to register user doc: ${response.status}`);
+    }
+}
+// glassware[type="implementation", id="impl-dev-login--d3f76c9b", specifications="specification-spec-create-user-doc--282489ae,specification-spec-token-storage--26199fe8"]
+/**
+ * Handle dev login - creates a local user document for testing without OAuth.
+ * This allows testing the full flow (auth → workspace creation → syncing) on localhost.
+ * Uses a shared dev@localhost user that both CLI and web app can access.
+ */
+async function handleDevLogin(repo) {
+    console.log('Setting up development authentication...');
+    const modUser = createModUser(repo);
+    try {
+        // Use findOrCreate to get shared dev user across CLI and web app
+        console.log('Looking for dev@localhost user...');
+        const userDoc = await modUser.findOrCreate({
+            email: 'dev@localhost',
+            name: 'Dev User',
+            googleId: 'dev-google-id',
+            avatar: null,
+        });
+        console.log('Using dev user document:', userDoc.id);
+        // Add user doc to share policy so it can sync
+        addUserToSharePolicy(userDoc.id);
+        // Store dev credentials in config
+        const config = readConfig();
+        config.auth = {
+            googleIdToken: 'dev-token',
+            userId: 'dev-user',
+            googleId: 'dev-google-id',
+            email: 'dev@localhost',
+            name: 'Dev User',
+            userDocId: userDoc.id,
+        };
+        writeConfig(config);
+        console.log('');
+        console.log('✓ Signed in as dev@localhost');
+        console.log(`  User Document ID: ${userDoc.id}`);
+        console.log('');
+        console.log('Note: This is development mode for local testing.');
+        console.log('Workspaces will sync via ws://localhost:3030');
+        console.log('The web app will use the same dev@localhost user.');
+    }
+    catch (error) {
+        console.error('Failed to setup dev user:', error.message);
+        process.exit(1);
+    }
 }