@plures/praxis 0.2.0

package/src/cli/commands/auth.ts

@@ -0,0 +1,271 @@
+/**
+ * Authentication CLI Commands
+ * 
+ * Commands for authenticating with GitHub for Praxis Cloud access.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { authenticateWithDeviceFlow } from "../../cloud/auth.js";
+import { createSponsorsClient } from "../../cloud/sponsors.js";
+import type { AuthResult } from "../../cloud/types.js";
+
+const AUTH_DIR = path.join(os.homedir(), ".praxis");
+const AUTH_FILE = path.join(AUTH_DIR, "auth.json");
+const GITHUB_CLIENT_ID = "Ov23liQxF7P0BqUxVXHk"; // Demo client ID (replace in production)
+
+interface StoredAuth {
+  token: string;
+  userId: number;
+  userLogin: string;
+  userName?: string;
+  userEmail?: string;
+  authenticatedAt: number;
+}
+
+/**
+ * Load stored authentication
+ */
+function loadAuth(): StoredAuth | null {
+  try {
+    if (fs.existsSync(AUTH_FILE)) {
+      const data = fs.readFileSync(AUTH_FILE, "utf-8");
+      return JSON.parse(data);
+    }
+  } catch (error) {
+    console.warn("Failed to load authentication:", error);
+  }
+  return null;
+}
+
+/**
+ * Save authentication
+ */
+function saveAuth(auth: StoredAuth): void {
+  try {
+    // Ensure directory exists
+    if (!fs.existsSync(AUTH_DIR)) {
+      fs.mkdirSync(AUTH_DIR, { recursive: true });
+    }
+    
+    // Save with restricted permissions
+    fs.writeFileSync(AUTH_FILE, JSON.stringify(auth, null, 2), { mode: 0o600 });
+    console.log(`\n✓ Authentication saved to ${AUTH_FILE}`);
+  } catch (error) {
+    console.error("Failed to save authentication:", error);
+    throw error;
+  }
+}
+
+/**
+ * Delete stored authentication
+ */
+function deleteAuth(): void {
+  try {
+    if (fs.existsSync(AUTH_FILE)) {
+      fs.unlinkSync(AUTH_FILE);
+    }
+  } catch (error) {
+    console.warn("Failed to delete authentication:", error);
+  }
+}
+
+/**
+ * Login command
+ */
+export async function loginCommand(options: { token?: string }): Promise<void> {
+  console.log("\n╔═══════════════════════════════════════════════════╗");
+  console.log("║   Praxis Cloud Authentication                     ║");
+  console.log("╚═══════════════════════════════════════════════════╝\n");
+  
+  // Check if already authenticated
+  const existingAuth = loadAuth();
+  if (existingAuth) {
+    console.log("⚠  Already authenticated");
+    console.log(`   User: ${existingAuth.userLogin}`);
+    console.log(`   Authenticated at: ${new Date(existingAuth.authenticatedAt).toLocaleString()}\n`);
+    console.log("Run 'praxis logout' to log out first.");
+    return;
+  }
+  
+  let authResult: AuthResult;
+  
+  if (options.token) {
+    // Use provided token
+    console.log("🔐 Using provided personal access token...");
+    
+    try {
+      const response = await fetch("https://api.github.com/user", {
+        headers: {
+          Authorization: `Bearer ${options.token}`,
+          Accept: "application/vnd.github.v3+json",
+        },
+      });
+      
+      if (!response.ok) {
+        throw new Error(`Invalid token: ${response.statusText}`);
+      }
+      
+      const userData = await response.json() as any;
+      
+      authResult = {
+        success: true,
+        token: options.token,
+        user: {
+          id: userData.id,
+          login: userData.login,
+          email: userData.email,
+          name: userData.name,
+          avatarUrl: userData.avatar_url,
+        },
+      };
+    } catch (error) {
+      console.error("\n✗ Authentication failed");
+      console.error(`  Error: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+  } else {
+    // Use device flow
+    console.log("🔐 Authenticating with GitHub device flow...");
+    authResult = await authenticateWithDeviceFlow(GITHUB_CLIENT_ID);
+  }
+  
+  if (!authResult.success || !authResult.token || !authResult.user) {
+    console.error("\n✗ Authentication failed");
+    process.exit(1);
+  }
+  
+  console.log(`✓ Authenticated as ${authResult.user.login}`);
+  
+  // Check GitHub Sponsors status
+  console.log("\n🔍 Checking GitHub Sponsors status...");
+  try {
+    const sponsorsClient = createSponsorsClient(authResult.token);
+    const subscription = await sponsorsClient.getSubscription(authResult.user.login);
+    
+    console.log(`✓ Subscription tier: ${subscription.tier}`);
+    console.log(`  Status: ${subscription.status}`);
+    console.log(`  Provider: ${subscription.provider}`);
+    
+    if (subscription.tier === "free") {
+      console.log("\n💡 Upgrade to a paid tier for more features!");
+      console.log("   Visit: https://github.com/sponsors/plures");
+    }
+  } catch (error) {
+    console.warn("\n⚠  Could not check Sponsors status");
+    console.warn(`   Error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  
+  // Save authentication
+  const storedAuth: StoredAuth = {
+    token: authResult.token,
+    userId: authResult.user.id,
+    userLogin: authResult.user.login,
+    userName: authResult.user.name,
+    userEmail: authResult.user.email,
+    authenticatedAt: Date.now(),
+  };
+  
+  saveAuth(storedAuth);
+  
+  console.log("\n✓ Successfully logged in!");
+  console.log("\nNext steps:");
+  console.log("  • Use 'praxis cloud init' to set up cloud connection");
+  console.log("  • Use 'praxis whoami' to check your authentication");
+  console.log("  • Use 'praxis cloud status' to check subscription\n");
+}
+
+/**
+ * Logout command
+ */
+export async function logoutCommand(): Promise<void> {
+  const auth = loadAuth();
+  
+  if (!auth) {
+    console.log("\n✗ Not currently logged in");
+    console.log("  Run 'praxis login' to authenticate\n");
+    return;
+  }
+  
+  console.log(`\nLogging out user: ${auth.userLogin}...`);
+  
+  deleteAuth();
+  
+  console.log("✓ Successfully logged out\n");
+}
+
+/**
+ * Whoami command
+ */
+export async function whoamiCommand(): Promise<void> {
+  const auth = loadAuth();
+  
+  if (!auth) {
+    console.log("\n✗ Not currently logged in");
+    console.log("  Run 'praxis login' to authenticate\n");
+    process.exit(1);
+  }
+  
+  console.log("\n╔═══════════════════════════════════════════════════╗");
+  console.log("║   Current Authentication                          ║");
+  console.log("╚═══════════════════════════════════════════════════╝\n");
+  
+  console.log(`User: ${auth.userLogin}`);
+  if (auth.userName) {
+    console.log(`Name: ${auth.userName}`);
+  }
+  if (auth.userEmail) {
+    console.log(`Email: ${auth.userEmail}`);
+  }
+  console.log(`User ID: ${auth.userId}`);
+  console.log(`Authenticated: ${new Date(auth.authenticatedAt).toLocaleString()}`);
+  
+  // Check token validity
+  console.log("\n🔍 Checking token validity...");
+  try {
+    const response = await fetch("https://api.github.com/user", {
+      headers: {
+        Authorization: `Bearer ${auth.token}`,
+        Accept: "application/vnd.github.v3+json",
+      },
+    });
+    
+    if (response.ok) {
+      console.log("✓ Token is valid");
+      
+      // Check subscription
+      console.log("\n🔍 Checking subscription...");
+      const sponsorsClient = createSponsorsClient(auth.token);
+      const subscription = await sponsorsClient.getSubscription(auth.userLogin);
+      
+      console.log(`Tier: ${subscription.tier}`);
+      console.log(`Status: ${subscription.status}`);
+      console.log(`Provider: ${subscription.provider}`);
+      console.log("\nLimits:");
+      console.log(`  Syncs/month: ${subscription.limits.maxSyncsPerMonth.toLocaleString()}`);
+      console.log(`  Storage: ${(subscription.limits.maxStorageBytes / 1024 / 1024).toFixed(0)} MB`);
+      console.log(`  Apps: ${subscription.limits.maxApps}`);
+      console.log(`  Team members: ${subscription.limits.maxTeamMembers ?? "Unlimited"}`);
+      console.log(`  Support: ${subscription.limits.supportLevel}`);
+    } else {
+      console.log("✗ Token is invalid or expired");
+      console.log("  Run 'praxis login' to re-authenticate");
+    }
+  } catch (error) {
+    console.error("\n✗ Failed to check token validity");
+    console.error(`  Error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  
+  console.log();
+}
+
+/**
+ * Get stored authentication token
+ * 
+ * Used by other commands that need authentication
+ */
+export function getAuthToken(): string | null {
+  const auth = loadAuth();
+  return auth?.token || null;
+}

package/src/cli/commands/cloud.ts

@@ -0,0 +1,281 @@
+/**
+ * Cloud CLI Commands
+ * 
+ * CLI commands for Praxis Cloud connectivity.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { authenticateWithDeviceFlow } from "../../cloud/auth.js";
+import { connectRelay } from "../../cloud/client.js";
+import type { CloudRelayConfig } from "../../cloud/types.js";
+
+const CONFIG_FILE = ".praxis-cloud.json";
+const GITHUB_CLIENT_ID = "Ov23liQxF7P0BqUxVXHk"; // Demo client ID (replace in production)
+
+interface StoredConfig {
+  endpoint: string;
+  appId: string;
+  authToken?: string;
+  autoSync?: boolean;
+  syncInterval?: number;
+}
+
+/**
+ * Load stored cloud configuration
+ */
+function loadConfig(): StoredConfig | null {
+  try {
+    const configPath = path.join(process.cwd(), CONFIG_FILE);
+    if (fs.existsSync(configPath)) {
+      const data = fs.readFileSync(configPath, "utf-8");
+      return JSON.parse(data);
+    }
+  } catch (error) {
+    console.warn("Failed to load cloud configuration:", error);
+  }
+  return null;
+}
+
+/**
+ * Save cloud configuration
+ */
+function saveConfig(config: StoredConfig): void {
+  try {
+    const configPath = path.join(process.cwd(), CONFIG_FILE);
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log(`\n✓ Configuration saved to ${CONFIG_FILE}`);
+  } catch (error) {
+    console.error("Failed to save cloud configuration:", error);
+    throw error;
+  }
+}
+
+/**
+ * Initialize cloud connection (wizard)
+ */
+export async function cloudInit(options: {
+  endpoint?: string;
+  appId?: string;
+  autoSync?: boolean;
+  interval?: string;
+}): Promise<void> {
+  console.log("\n╔═══════════════════════════════════════════════════╗");
+  console.log("║   Welcome to Praxis Cloud Setup Wizard           ║");
+  console.log("╚═══════════════════════════════════════════════════╝\n");
+
+  // Check if already configured
+  const existingConfig = loadConfig();
+  if (existingConfig) {
+    console.log("⚠  Existing cloud configuration found.");
+    console.log(`   Endpoint: ${existingConfig.endpoint}`);
+    console.log(`   App ID: ${existingConfig.appId}\n`);
+    // In production, prompt user to confirm overwrite
+  }
+
+  // Get endpoint
+  let endpoint = options.endpoint;
+  if (!endpoint) {
+    // In production, prompt user for input
+    endpoint = "https://praxis-relay.azurewebsites.net";
+    console.log(`Using default endpoint: ${endpoint}`);
+  }
+
+  // Get app ID
+  let appId = options.appId;
+  if (!appId) {
+    // In production, prompt user for input or generate from git remote
+    appId = path.basename(process.cwd());
+    console.log(`Using app ID from directory name: ${appId}`);
+  }
+
+  // Authenticate with GitHub
+  console.log("\n🔐 Authenticating with GitHub...");
+  const authResult = await authenticateWithDeviceFlow(GITHUB_CLIENT_ID);
+
+  if (!authResult.success || !authResult.token) {
+    console.error("\n✗ Authentication failed");
+    process.exit(1);
+  }
+
+  console.log(`✓ Authenticated as ${authResult.user?.login || "unknown"}`);
+
+  // Test connection
+  console.log("\n🔗 Testing connection to Praxis Cloud...");
+
+  try {
+    const config: CloudRelayConfig = {
+      endpoint,
+      appId,
+      authToken: authResult.token,
+      autoSync: options.autoSync,
+      syncInterval: options.interval ? parseInt(options.interval) : 5000,
+    };
+
+    const client = await connectRelay(endpoint, config);
+    const health = await client.getHealth();
+
+    if (health.status === "healthy") {
+      console.log("✓ Connected successfully!");
+      console.log(`  Status: ${health.status}`);
+      console.log(`  Version: ${health.version}`);
+    } else {
+      console.log(`⚠  Connected but service is ${health.status}`);
+    }
+
+    await client.disconnect();
+
+    // Save configuration
+    const storedConfig: StoredConfig = {
+      endpoint,
+      appId,
+      authToken: authResult.token,
+      autoSync: options.autoSync,
+      syncInterval: config.syncInterval,
+    };
+
+    saveConfig(storedConfig);
+
+    console.log("\n✓ Praxis Cloud is now configured!");
+    console.log("\nNext steps:");
+    console.log("  • Use 'praxis cloud status' to check connection");
+    console.log("  • Use 'praxis cloud sync' to manually sync");
+    console.log("  • Use 'praxis cloud usage' to view metrics");
+    console.log("\nIn your code:");
+    console.log('  import { connectRelay } from "@plures/praxis/cloud";');
+    console.log(`  const relay = await connectRelay("${endpoint}", {`);
+    console.log(`    appId: "${appId}",`);
+    console.log(`    authToken: "<your-token>"`);
+    console.log("  });\n");
+  } catch (error) {
+    console.error("\n✗ Failed to connect to Praxis Cloud");
+    console.error(`  Error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Check cloud connection status
+ */
+export async function cloudStatus(): Promise<void> {
+  const config = loadConfig();
+
+  if (!config) {
+    console.log("\n✗ No cloud configuration found");
+    console.log("  Run 'praxis cloud init' to set up cloud connection\n");
+    process.exit(1);
+  }
+
+  console.log("\n╔═══════════════════════════════════════════════════╗");
+  console.log("║   Praxis Cloud Status                             ║");
+  console.log("╚═══════════════════════════════════════════════════╝\n");
+
+  console.log(`Endpoint: ${config.endpoint}`);
+  console.log(`App ID: ${config.appId}`);
+  console.log(`Auto Sync: ${config.autoSync ? "enabled" : "disabled"}`);
+
+  if (config.autoSync) {
+    console.log(`Sync Interval: ${config.syncInterval}ms`);
+  }
+
+  try {
+    const client = await connectRelay(config.endpoint, config);
+    const health = await client.getHealth();
+
+    console.log(`\nConnection: ✓ Connected`);
+    console.log(`Status: ${health.status}`);
+    console.log(`Version: ${health.version}`);
+    console.log("\nServices:");
+    console.log(`  Relay: ${health.services.relay ? "✓" : "✗"}`);
+    console.log(`  Event Grid: ${health.services.eventGrid ? "✓" : "✗"}`);
+    console.log(`  Storage: ${health.services.storage ? "✓" : "✗"}`);
+    console.log(`  Auth: ${health.services.auth ? "✓" : "✗"}`);
+
+    await client.disconnect();
+  } catch (error) {
+    console.log(`\nConnection: ✗ Failed`);
+    console.log(`Error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  console.log();
+}
+
+/**
+ * Manually trigger cloud sync
+ */
+export async function cloudSync(): Promise<void> {
+  const config = loadConfig();
+
+  if (!config) {
+    console.log("\n✗ No cloud configuration found");
+    console.log("  Run 'praxis cloud init' to set up cloud connection\n");
+    process.exit(1);
+  }
+
+  console.log("\n🔄 Syncing to Praxis Cloud...");
+
+  try {
+    const client = await connectRelay(config.endpoint, config);
+
+    // In production, collect actual facts and events to sync
+    await client.sync({
+      type: "delta",
+      appId: config.appId,
+      clock: {},
+      facts: [],
+      events: [],
+      timestamp: Date.now(),
+    });
+
+    console.log("✓ Sync completed successfully\n");
+
+    await client.disconnect();
+  } catch (error) {
+    console.error("\n✗ Sync failed");
+    console.error(`  Error: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+  }
+}
+
+/**
+ * View cloud usage metrics
+ */
+export async function cloudUsage(): Promise<void> {
+  const config = loadConfig();
+
+  if (!config) {
+    console.log("\n✗ No cloud configuration found");
+    console.log("  Run 'praxis cloud init' to set up cloud connection\n");
+    process.exit(1);
+  }
+
+  console.log("\n╔═══════════════════════════════════════════════════╗");
+  console.log("║   Praxis Cloud Usage Metrics                      ║");
+  console.log("╚═══════════════════════════════════════════════════╝\n");
+
+  try {
+    const client = await connectRelay(config.endpoint, config);
+    const usage = await client.getUsage();
+
+    console.log(`App ID: ${usage.appId}`);
+    console.log(`\nMetrics:`);
+    console.log(`  Total Syncs: ${usage.syncCount}`);
+    console.log(`  Events Forwarded: ${usage.eventCount}`);
+    console.log(`  Facts Synced: ${usage.factCount}`);
+    console.log(`  Storage Used: ${(usage.storageBytes / 1024).toFixed(2)} KB`);
+
+    const periodDuration = usage.periodEnd - usage.periodStart;
+    const durationHours = (periodDuration / 1000 / 60 / 60).toFixed(1);
+    console.log(`\nPeriod: ${durationHours} hours`);
+    console.log(`  From: ${new Date(usage.periodStart).toLocaleString()}`);
+    console.log(`  To: ${new Date(usage.periodEnd).toLocaleString()}`);
+
+    console.log();
+
+    await client.disconnect();
+  } catch (error) {
+    console.error("\n✗ Failed to retrieve usage metrics");
+    console.error(`  Error: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+  }
+}