@mod-computer/cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import dotenv from 'dotenv';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { render } from 'ink';
+import App from './app.js';
+import { repo as getRepo } from '@mod/mod-core/repos/repo.node';
+import { buildCommandRegistry } from './commands/index.js';
+import meow from 'meow';
+// Background watch functionality removed - using automatic-file-tracker instead
+import { getFeatureFlags } from './services/feature-flags.js';
+import { FEATURES, isFeatureEnabled } from './config/features.js';
+// Load environment variables from multiple candidate locations
+// 1) CWD (project dir where user runs `mod`)
+dotenv.config({ override: false, debug: false, quiet: true });
+// 2) Package-local .env (e.g., packages/mod-cli/.env) for monorepo development
+try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    // dist/cli.js -> ../.env
+    const pkgEnv = path.join(__dirname, '../.env');
+    dotenv.config({ path: pkgEnv, override: true, debug: false, quiet: true });
+    // monorepo root .env (two levels up from packages/mod-cli/dist)
+    const rootEnv = path.join(__dirname, '../../../.env');
+    dotenv.config({ path: rootEnv, override: true, debug: false, quiet: true });
+}
+catch { }
+// Note: AI features are lazily imported in thread-service to keep bootstrap light.
+// Note: Startup logging removed to reduce noise in alpha mode
+// Suppress extremely chatty Automerge sync noise that breaks TTY input rendering
+try {
+    const noisy = [
+        'error receiving message',
+        'Attempting to change an outdated document',
+    ];
+    const shouldDrop = (args) => {
+        try {
+            const s = args.map(a => (typeof a === 'string' ? a : (a && a.stack) || JSON.stringify(a))).join(' ');
+            return noisy.some(k => s.includes(k));
+        }
+        catch {
+            return false;
+        }
+    };
+    const origLog = console.log.bind(console);
+    const origErr = console.error.bind(console);
+    const origWarn = console.warn.bind(console);
+    console.log = (...args) => { if (shouldDrop(args))
+        return; origLog(...args); };
+    console.error = (...args) => { if (shouldDrop(args))
+        return; origErr(...args); };
+    console.warn = (...args) => { if (shouldDrop(args))
+        return; origWarn(...args); };
+}
+catch { }
+const cli = meow(`
+  Usage
+    $ mod <command> [options]
+  Commands
+    create-task <desc>
+    set-task-status <id> <status>
+    ...
+`, {
+    importMeta: import.meta,
+    flags: {
+        preview: {
+            type: 'boolean',
+            default: false
+        },
+        verbose: {
+            type: 'boolean',
+            default: false
+        },
+        force: {
+            type: 'boolean',
+            default: false
+        }
+    },
+    allowUnknownFlags: true
+});
+async function main() {
+    const repo = await getRepo();
+    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;
+    }
+    if (!cmd) {
+        console.log('Mod CLI\n');
+        console.log('Available commands:');
+        for (const command of Object.keys(availableCommands).sort()) {
+            console.log(`  mod ${command}`);
+        }
+        return;
+    }
+    if (cmd && !availableCommands[cmd]) {
+        console.error(`Unknown command: ${cmd}`);
+        console.error('Run "mod" to see available commands.');
+        process.exit(1);
+    }
+    // Ink UI rendering controlled by features, not exposed to users
+    if (isFeatureEnabled(FEATURES.STATUS) || Object.keys(availableCommands).length > 1) {
+        const featureFlags = getFeatureFlags(); // Keep for backward compatibility with App component
+        render(_jsx(App, { repo: repo, featureFlags: featureFlags }));
+    }
+}
+main();

package/dist/commands/agents-run.js

@@ -0,0 +1,71 @@
+import { readModConfig } from '../services/mod-config.js';
+import { ThreadService } from '@mod/mod-core/services/thread-service';
+export async function agentsRunCommand(args, repo) {
+    // Usage: mod agents-run --prompt "..." [--agent dev|planner]
+    const promptIndex = args.findIndex(a => a === '--prompt');
+    const agentIndex = args.findIndex(a => a === '--agent');
+    const prompt = promptIndex !== -1 ? args[promptIndex + 1] : undefined;
+    const agentName = agentIndex !== -1 ? (args[agentIndex + 1] || 'dev') : 'dev';
+    if (!prompt) {
+        console.error('Usage: mod agents-run --prompt "..." [--agent dev|planner]');
+        process.exit(1);
+    }
+    const config = readModConfig();
+    if (!config?.workspaceId) {
+        console.error('No active workspace found in .mod/config.json');
+        process.exit(1);
+    }
+    const wsHandle = await repo.find(config.workspaceId);
+    const workspace = await wsHandle.doc();
+    if (!workspace) {
+        console.error('Workspace not found');
+        process.exit(1);
+    }
+    const threadService = new ThreadService(repo);
+    const threadId = workspace.activeThreadId || (await (async () => {
+        const t = await threadService.createThreadWithBranch(workspace.id, workspace.branchesDocId, workspace.activeBranchId, 'CLI Thread');
+        return t.id;
+    })());
+    // Lazy import agents (shimmed types)
+    // Agent packages not yet available - placeholder implementation
+    console.error('Agent packages (@mod/mod-agents) are not yet implemented');
+    console.log(`Requested agent: ${agentName}`);
+    process.exit(1);
+    /*
+    let agent: any;
+    if (agentName === 'planner' || agentName === 'plan') {
+      const mod = await import('@mod/mod-agents/planner');
+      agent = (mod as any).plannerAgent || (mod as any).default;
+    } else {
+      const mod = await import('@mod/mod-agents/dev-agent');
+      agent = (mod as any).devAgent || (mod as any).default;
+    }
+    */
+    /*
+    const tools: Record<string, any> = {};
+    const apiKey = process.env.OPENAI_API_KEY || process.env.OPENAI || process.env.ANTHROPIC_API_KEY || '';
+    try {
+      for await (const chunk of chatWithAgentCli({
+        repo: repo as any,
+        threadId: threadId as any,
+        userMessage: prompt,
+        workspace,
+        agent,
+        tools,
+        apiKey,
+      })) {
+        if (chunk.type === 'content') {
+          process.stdout.write(chunk.content);
+        } else if (chunk.type === 'tool-call') {
+          log('[tool-call]', (chunk as any).toolName || '');
+        } else if (chunk.type === 'tool-result') {
+          log('[tool-result]', (chunk as any).output?.toolName || '');
+        }
+      }
+    } catch (e: any) {
+      console.error('Agent run failed:', e?.message || e);
+    } finally {
+      setTimeout(() => process.exit(0), 500);
+    }
+    */
+}

package/dist/commands/auth.js

@@ -0,0 +1,151 @@
+// 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]
+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';
+export async function authCommand(args, repo) {
+    const [subcommand] = args;
+    switch (subcommand) {
+        case 'login':
+            await handleLogin();
+            break;
+        case 'logout':
+            await handleLogout();
+            break;
+        case 'status':
+            await handleStatus();
+            break;
+        default:
+            if (!subcommand) {
+                await handleStatus();
+            }
+            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');
+                process.exit(1);
+            }
+    }
+    process.exit(0);
+}
+async function handleLogin() {
+    // Check if already authenticated
+    const config = readConfig();
+    if (config.auth) {
+        console.log(`Already signed in as ${config.auth.email}`);
+        console.log('');
+        console.log('Run `mod auth logout` to sign out first.');
+        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}`;
+    console.log('Opening browser to sign in...');
+    // Try to open browser
+    const opened = await openBrowser(authUrl);
+    if (!opened) {
+        console.log('');
+        console.log('Could not open browser. Please visit:');
+        console.log(authUrl);
+        console.log('');
+    }
+    console.log('Waiting for authentication...');
+    try {
+        // Wait for auth callback
+        const authResult = await result;
+        // Validate token with server (optional - server may not be available)
+        let userDocId;
+        try {
+            userDocId = await validateAndGetUserDocId(authResult.googleIdToken);
+        }
+        catch (error) {
+            // If validation fails, continue without userDocId
+            // It will be set on first sync
+        }
+        // Store credentials in config
+        const updatedConfig = readConfig();
+        updatedConfig.auth = {
+            googleIdToken: authResult.googleIdToken,
+            googleId: authResult.googleId,
+            email: authResult.email,
+            name: authResult.name,
+            userDocId: userDocId || '',
+        };
+        writeConfig(updatedConfig);
+        console.log('');
+        console.log(`Signed in as ${authResult.email}`);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.message.includes('timed out')) {
+                console.error('');
+                console.error('Authentication timed out. Please try again.');
+            }
+            else if (error.message.includes('cancelled')) {
+                console.error('');
+                console.error('Authentication cancelled.');
+            }
+            else {
+                console.error('');
+                console.error(`Authentication failed: ${error.message}`);
+            }
+        }
+        process.exit(1);
+    }
+}
+async function handleLogout() {
+    const config = readConfig();
+    if (!config.auth) {
+        console.log('Not signed in.');
+        return;
+    }
+    const email = config.auth.email;
+    // Clear auth from config
+    config.auth = null;
+    writeConfig(config);
+    console.log('Signed out successfully');
+    console.log(`Removed credentials for ${email}`);
+}
+async function handleStatus() {
+    const config = readConfig();
+    if (!config.auth) {
+        console.log('Not signed in.');
+        console.log('');
+        console.log('Sign in to sync with collaborators: mod auth login');
+        return;
+    }
+    console.log(`Signed in as ${config.auth.email}`);
+    if (config.auth.name && config.auth.name !== config.auth.email) {
+        console.log(`Name: ${config.auth.name}`);
+    }
+    console.log('Token expires: never');
+    // Check if token is still valid (optional)
+    try {
+        await validateAndGetUserDocId(config.auth.googleIdToken);
+        console.log('Token status: valid');
+    }
+    catch (error) {
+        console.log('Token status: could not verify (server unavailable)');
+    }
+}
+/**
+ * Validate token with server and get user document ID.
+ * Returns existing userDocId for returning users, or undefined for new users.
+ */
+async function validateAndGetUserDocId(token) {
+    const response = await fetch(`${API_BASE_URL}/auth/me`, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error('Token validation failed');
+    }
+    const data = (await response.json());
+    return data.userDocId;
+}