@mmapp/react-compiler 0.1.0-alpha.1

package/src/cli/auth.ts

@@ -0,0 +1,255 @@
+/**
+ * CLI Auth — login, logout, whoami, and token resolution.
+ *
+ * Credentials are stored in ~/.mmrc/credentials.json keyed by API URL.
+ * Token resolution order: explicit --token > MMRC_TOKEN env > saved credentials.
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { createInterface } from 'readline';
+
+// =============================================================================
+// Types
+// =============================================================================
+
+interface CredentialEntry {
+  token: string;
+  savedAt: string;
+}
+
+type CredentialsFile = Record<string, CredentialEntry>;
+
+// =============================================================================
+// Paths
+// =============================================================================
+
+const MMRC_DIR = join(homedir(), '.mmrc');
+const CREDENTIALS_PATH = join(MMRC_DIR, 'credentials.json');
+
+// =============================================================================
+// Credential Storage
+// =============================================================================
+
+export function loadCredentials(): CredentialsFile {
+  if (!existsSync(CREDENTIALS_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync(CREDENTIALS_PATH, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+export function saveCredentials(apiUrl: string, token: string): void {
+  mkdirSync(MMRC_DIR, { recursive: true, mode: 0o700 });
+  const creds = loadCredentials();
+  creds[apiUrl] = { token, savedAt: new Date().toISOString() };
+  writeFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), 'utf-8');
+  // Restrict file permissions (owner-only read/write)
+  try {
+    const { chmodSync } = require('fs');
+    chmodSync(CREDENTIALS_PATH, 0o600);
+  } catch {
+    // Windows doesn't support chmod — ignore
+  }
+}
+
+function removeCredentials(apiUrl?: string): void {
+  if (!existsSync(CREDENTIALS_PATH)) return;
+
+  if (!apiUrl) {
+    // Remove all
+    unlinkSync(CREDENTIALS_PATH);
+    return;
+  }
+
+  const creds = loadCredentials();
+  delete creds[apiUrl];
+
+  if (Object.keys(creds).length === 0) {
+    unlinkSync(CREDENTIALS_PATH);
+  } else {
+    writeFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), 'utf-8');
+  }
+}
+
+// =============================================================================
+// Token Resolution
+// =============================================================================
+
+/**
+ * Resolve an auth token using the priority chain:
+ *   1. Explicit --token flag
+ *   2. MMRC_TOKEN environment variable
+ *   3. Saved credentials for the given apiUrl
+ *
+ * Returns the token string or null if none found.
+ */
+export function resolveToken(apiUrl: string, explicitToken?: string): string | null {
+  // 1. Explicit token
+  if (explicitToken) return explicitToken;
+
+  // 2. Environment variable
+  const envToken = process.env.MMRC_TOKEN;
+  if (envToken) return envToken;
+
+  // 3. Saved credentials
+  const creds = loadCredentials();
+  const entry = creds[apiUrl];
+  if (entry?.token) return entry.token;
+
+  return null;
+}
+
+// =============================================================================
+// Interactive Prompt
+// =============================================================================
+
+function prompt(question: string, hidden = false): Promise<string> {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    if (hidden && process.stdin.isTTY) {
+      // Mute output for password input
+      const origWrite = process.stdout.write.bind(process.stdout);
+      process.stdout.write = ((
+        chunk: string | Uint8Array,
+        encodingOrCb?: BufferEncoding | ((err?: Error) => void),
+        cb?: (err?: Error) => void
+      ): boolean => {
+        if (typeof chunk === 'string' && chunk.includes(question)) {
+          return origWrite(chunk, encodingOrCb as BufferEncoding, cb);
+        }
+        // Suppress echoed characters
+        if (typeof chunk === 'string' && !chunk.includes('\n')) {
+          return true;
+        }
+        return origWrite(chunk, encodingOrCb as BufferEncoding, cb);
+      }) as typeof process.stdout.write;
+
+      rl.question(question, (answer) => {
+        process.stdout.write = origWrite;
+        console.log(); // newline after hidden input
+        rl.close();
+        resolve(answer.trim());
+      });
+    } else {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    }
+  });
+}
+
+// =============================================================================
+// Commands
+// =============================================================================
+
+/**
+ * Login: authenticate with email/password, save token.
+ */
+export async function login(
+  apiUrl: string,
+  email?: string,
+  password?: string
+): Promise<string> {
+  // Prompt interactively if not provided
+  if (!email) {
+    email = await prompt('Email: ');
+  }
+  if (!password) {
+    password = await prompt('Password: ', true);
+  }
+
+  if (!email || !password) {
+    throw new Error('Email and password are required');
+  }
+
+  console.log(`[mmrc] Logging in to ${apiUrl}...`);
+
+  const res = await fetch(`${apiUrl}/auth/login`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ email, password }),
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Login failed: ${res.status} ${text}`);
+  }
+
+  const data = (await res.json()) as Record<string, unknown>;
+  const token =
+    (data.token as string) ??
+    (data.access_token as string) ??
+    (data.accessToken as string);
+
+  if (!token) {
+    throw new Error('Login succeeded but no token in response');
+  }
+
+  saveCredentials(apiUrl, token);
+
+  const userName =
+    (data.name as string) ??
+    (data.user as Record<string, unknown>)?.name ??
+    (data.user as Record<string, unknown>)?.email ??
+    email;
+  console.log(`[mmrc] Logged in as ${userName}`);
+  console.log(`[mmrc] Token saved to ${CREDENTIALS_PATH}`);
+
+  return token;
+}
+
+/**
+ * Logout: remove saved credentials.
+ */
+export function logout(apiUrl?: string): void {
+  if (apiUrl) {
+    removeCredentials(apiUrl);
+    console.log(`[mmrc] Credentials removed for ${apiUrl}`);
+  } else {
+    removeCredentials();
+    console.log('[mmrc] All saved credentials removed');
+  }
+}
+
+/**
+ * Whoami: show current user info using saved token.
+ */
+export async function whoami(apiUrl: string): Promise<void> {
+  const token = resolveToken(apiUrl);
+  if (!token) {
+    console.log('[mmrc] Not logged in. Run `mmrc login` to authenticate.');
+    return;
+  }
+
+  try {
+    const res = await fetch(`${apiUrl}/auth/me`, {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+
+    if (!res.ok) {
+      if (res.status === 401) {
+        console.log('[mmrc] Token is expired or invalid. Run `mmrc login` to re-authenticate.');
+        return;
+      }
+      console.log(`[mmrc] Failed to fetch user info: ${res.status}`);
+      return;
+    }
+
+    const user = (await res.json()) as Record<string, unknown>;
+    console.log(`[mmrc] Logged in to ${apiUrl}`);
+    console.log(`  Name:  ${user.name ?? '(unknown)'}`);
+    console.log(`  Email: ${user.email ?? '(unknown)'}`);
+    if (user.id) console.log(`  ID:    ${user.id}`);
+    if (user.role) console.log(`  Role:  ${user.role}`);
+  } catch (error) {
+    console.log(`[mmrc] Could not connect to ${apiUrl}: ${(error as Error).message}`);
+  }
+}

package/src/cli/build.ts

@@ -0,0 +1,288 @@
+/**
+ * CLI Build Command — compiles workflow files to Pure Form JSON.
+ *
+ * Supports three file types:
+ * - *.workflow.tsx — React workflow components
+ * - models/*.ts — TypeScript model files
+ * - *.server.ts — Server action files
+ *
+ * Produces:
+ * - *.workflow.json — IR (Pure Form)
+ * - *.json — Engine-compatible definition
+ * - envelope.json — Source envelope with file manifest
+ */
+
+import { glob } from 'glob';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { transformSync } from '@babel/core';
+import { join, basename, dirname, resolve } from 'path';
+import { execSync } from 'child_process';
+import babelPlugin from '../babel';
+import type { IRWorkflowDefinition } from '@mindmatrix/player-core';
+import { generateFsTree } from '../envelope/fs-tree';
+import { createSourceEnvelope } from '../envelope/source-envelope';
+
+export interface BuildOptions {
+  src?: string;
+  outDir?: string;
+  mode?: 'strict' | 'infer';
+  /** Generate source envelope. */
+  envelope?: boolean;
+  /** Blueprint slug for envelope. */
+  slug?: string;
+  /** Blueprint version for envelope. */
+  version?: string;
+  /** Skip TypeScript type checking (not recommended). */
+  skipTypeCheck?: boolean;
+}
+
+export interface BuildResult {
+  compiled: number;
+  errors: number;
+  warnings: number;
+  definitions: IRWorkflowDefinition[];
+  errorDetails: { file: string; message: string; line?: number }[];
+}
+
+export async function build(options: BuildOptions = {}): Promise<BuildResult> {
+  const srcDir = options.src ?? 'src/workflows';
+  const outDir = options.outDir ?? 'dist/workflows';
+  const mode = options.mode ?? 'infer';
+
+  // ─── Type Checking ────────────────────────────────────────────────────────
+  // Run tsc --noEmit before Babel compilation to catch type errors early.
+  // Babel strips types without checking — this ensures type safety.
+  if (!options.skipTypeCheck) {
+    const tsconfigPath = resolve(srcDir, 'tsconfig.json');
+    const hasTsconfig = existsSync(tsconfigPath);
+
+    if (hasTsconfig) {
+      console.log(`[mindmatrix-react] Type checking (tsc --noEmit)...`);
+      try {
+        execSync(`npx tsc --noEmit --project ${tsconfigPath}`, {
+          cwd: resolve(srcDir),
+          stdio: 'pipe',
+          encoding: 'utf-8',
+        });
+        console.log(`[mindmatrix-react] Type check passed.`);
+      } catch (err: unknown) {
+        const tscError = err as { stdout?: string; stderr?: string };
+        const output = tscError.stdout || tscError.stderr || '';
+        // Parse tsc output into individual errors
+        const lines = output.split('\n').filter(l => l.trim());
+        const typeErrors: { file: string; message: string; line?: number }[] = [];
+        for (const line of lines) {
+          // tsc format: file(line,col): error TS1234: message
+          const match = line.match(/^(.+?)\((\d+),\d+\):\s*error\s+(TS\d+):\s*(.+)$/);
+          if (match) {
+            typeErrors.push({
+              file: match[1],
+              message: `${match[3]}: ${match[4]}`,
+              line: parseInt(match[2], 10),
+            });
+          }
+        }
+
+        if (typeErrors.length > 0) {
+          console.error(`\n[mindmatrix-react] Type check failed with ${typeErrors.length} error(s):\n`);
+          for (const te of typeErrors) {
+            console.error(`  ✗ ${te.file}:${te.line || '?'} ${te.message}`);
+          }
+          console.error(`\n[mindmatrix-react] Fix type errors or use --skip-type-check to bypass.\n`);
+          return {
+            compiled: 0,
+            errors: typeErrors.length,
+            warnings: 0,
+            definitions: [],
+            errorDetails: typeErrors,
+          };
+        } else {
+          // Unrecognized tsc output — still fail
+          console.error(`\n[mindmatrix-react] Type check failed:\n${output}`);
+          return {
+            compiled: 0,
+            errors: 1,
+            warnings: 0,
+            definitions: [],
+            errorDetails: [{ file: 'tsconfig.json', message: output.slice(0, 500) }],
+          };
+        }
+      }
+    }
+  }
+
+  // Check if this is a project (has mm.config.ts) → use project compiler
+  const configPath = resolve(srcDir, 'mm.config.ts');
+  if (existsSync(configPath)) {
+    console.log(`[mindmatrix-react] Detected mm.config.ts — using project compiler...`);
+    const { compileProject } = await import('../project-compiler') as { compileProject: Function };
+    const allProjectFiles = await glob(`${srcDir}/**/*.{ts,tsx}`, {
+      ignore: ['**/node_modules/**', '**/dist/**', '**/__tests__/**', '**/*.test.*'],
+    });
+
+    const fileMap: Record<string, string> = {};
+    for (const f of allProjectFiles) {
+      const rel = f.startsWith(srcDir + '/') ? f.slice(srcDir.length + 1) : f;
+      fileMap[rel] = readFileSync(f, 'utf-8');
+    }
+
+    mkdirSync(outDir, { recursive: true });
+    const result = compileProject(fileMap, { mode }) as {
+      ir: IRWorkflowDefinition;
+      childDefinitions: IRWorkflowDefinition[];
+      errors: { file: string; message: string; line?: number; severity: string }[];
+    };
+    const errors = result.errors.filter(e => e.severity === 'error');
+    const warnings = result.errors.filter(e => e.severity === 'warning');
+
+    const definitions: IRWorkflowDefinition[] = [result.ir];
+    const errorDetails: { file: string; message: string; line?: number }[] = [];
+
+    for (const err of errors) {
+      errorDetails.push({ file: err.file, message: err.message, line: err.line });
+      console.error(`  x ${err.file}${err.line ? `:${err.line}` : ''} ${err.message}`);
+    }
+    for (const warn of warnings) {
+      console.warn(`  ! ${warn.file}${warn.line ? `:${warn.line}` : ''} ${warn.message}`);
+    }
+
+    // Write parent IR
+    const irPath = join(outDir, `${result.ir.slug}.workflow.json`);
+    writeFileSync(irPath, JSON.stringify(result.ir, null, 2), 'utf-8');
+    console.log(`  + ${basename(irPath)}`);
+
+    // Write child definitions
+    const seenSlugs = new Set<string>([result.ir.slug]);
+    for (const child of result.childDefinitions) {
+      if (seenSlugs.has(child.slug)) continue;
+      seenSlugs.add(child.slug);
+      definitions.push(child);
+      const childPath = join(outDir, `${child.slug}.workflow.json`);
+      writeFileSync(childPath, JSON.stringify(child, null, 2), 'utf-8');
+      console.log(`  + ${basename(childPath)}`);
+    }
+
+    console.log(`\n[mindmatrix-react] Compiled ${definitions.length} definitions, ${errors.length} errors, ${warnings.length} warnings`);
+    return { compiled: definitions.length, errors: errors.length, warnings: warnings.length, definitions, errorDetails };
+  }
+
+  console.log(`[mindmatrix-react] Building workflows from ${srcDir}...`);
+
+  // Ensure output directory exists
+  mkdirSync(outDir, { recursive: true });
+
+  // Find all compilable files
+  const workflowFiles = await glob(`${srcDir}/**/*.workflow.{tsx,ts,jsx,js}`);
+  const modelFiles = await glob(`${srcDir}/**/models/**/*.{ts,tsx}`);
+  const serverFiles = await glob(`${srcDir}/**/*.server.{ts,tsx,js,jsx}`);
+
+  const allFiles = [...new Set([...workflowFiles, ...modelFiles, ...serverFiles])];
+
+  if (allFiles.length === 0) {
+    console.log(`[mindmatrix-react] No workflow files found in ${srcDir}`);
+    return { compiled: 0, errors: 0, warnings: 0, definitions: [], errorDetails: [] };
+  }
+
+  let compiled = 0;
+  let errorCount = 0;
+  let warningCount = 0;
+  const definitions: IRWorkflowDefinition[] = [];
+  const errorDetails: { file: string; message: string; line?: number }[] = [];
+
+  for (const file of allFiles) {
+    try {
+      const code = readFileSync(file, 'utf-8');
+      const result = transformSync(code, {
+        filename: file,
+        plugins: [[babelPlugin, { mode }]],
+        parserOpts: { plugins: ['jsx', 'typescript'], attachComment: true },
+      });
+
+      const ir = (result as any)?.metadata?.mindmatrixIR;
+      const definition = (result as any)?.metadata?.mindmatrixDefinition;
+      const canonical = (result as any)?.metadata?.mindmatrixCanonical;
+
+      if (ir) {
+        definitions.push(ir);
+
+        // Check for compiler errors
+        const irErrors = (ir.metadata as any)?.errors;
+        const irWarnings = (ir.metadata as any)?.warnings;
+
+        if (irErrors && irErrors.length > 0) {
+          for (const err of irErrors) {
+            errorDetails.push({
+              file: basename(file),
+              message: err.message,
+              line: err.line,
+            });
+            console.error(`  ✗ ${basename(file)}:${err.line || '?'} ${err.message}`);
+          }
+          errorCount += irErrors.length;
+        }
+
+        if (irWarnings && irWarnings.length > 0) {
+          for (const warn of irWarnings) {
+            console.warn(`  ⚠ ${basename(file)}:${warn.line || '?'} ${warn.message}`);
+          }
+          warningCount += irWarnings.length;
+        }
+
+        // Write combined compiled output { canonical, ir } — the standard format
+        const compiledFileName = basename(file)
+          .replace(/\.workflow\.(tsx?|jsx?)$/, '.json')
+          .replace(/\.(tsx?|jsx?)$/, '.json');
+        const compiledFile = join(outDir, compiledFileName);
+        mkdirSync(dirname(compiledFile), { recursive: true });
+        writeFileSync(compiledFile, JSON.stringify({ canonical, ir }, null, 2), 'utf-8');
+
+        // Write IR-only file (for deploy command)
+        const irFileName = basename(file)
+          .replace(/\.workflow\.(tsx?|jsx?)$/, '.workflow.json')
+          .replace(/\.(tsx?|jsx?)$/, '.json');
+        const irFile = join(outDir, irFileName);
+        writeFileSync(irFile, JSON.stringify(ir, null, 2), 'utf-8');
+
+        // Write engine-compatible definition
+        if (definition) {
+          const defFileName = basename(file).replace(/\.workflow\.(tsx?|jsx?)$/, '.def.json').replace(/\.(tsx?|jsx?)$/, '.def.json');
+          const defFile = join(outDir, defFileName);
+          writeFileSync(defFile, JSON.stringify(definition, null, 2), 'utf-8');
+        }
+
+        console.log(`  ✓ ${basename(file)} → ${compiledFileName}`);
+        compiled++;
+      } else {
+        console.error(`  ✗ ${basename(file)}: No IR generated`);
+        errorDetails.push({ file: basename(file), message: 'No IR generated' });
+        errorCount++;
+      }
+    } catch (error) {
+      const msg = (error as Error).message;
+      console.error(`  ✗ ${basename(file)}: ${msg}`);
+      errorDetails.push({ file: basename(file), message: msg });
+      errorCount++;
+    }
+  }
+
+  // Generate source envelope if requested
+  if (options.envelope) {
+    const allSourceFiles = await glob(`${srcDir}/**/*.{ts,tsx,js,jsx}`);
+    const fsTree = generateFsTree(allSourceFiles, resolve(srcDir));
+    const envelope = createSourceEnvelope({
+      blueprintSlug: options.slug || 'project',
+      blueprintVersion: options.version || '0.1.0',
+      definitions,
+      fsTree,
+      mode,
+    });
+
+    const envelopePath = join(outDir, 'envelope.json');
+    writeFileSync(envelopePath, JSON.stringify(envelope, null, 2), 'utf-8');
+    console.log(`\n  ✓ Source envelope → envelope.json (${envelope.envelopeId.substring(0, 8)})`);
+  }
+
+  console.log(`\n[mindmatrix-react] Compiled ${compiled} workflows, ${errorCount} errors, ${warningCount} warnings`);
+
+  return { compiled, errors: errorCount, warnings: warningCount, definitions, errorDetails };
+}