native-update 1.0.8 → 1.1.0

package/cli/commands/backend-create.js

@@ -0,0 +1,582 @@
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import ora from 'ora';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export async function createBackend(type, options) {
+  const spinner = ora(`Creating ${type} backend template...`).start();
+
+  try {
+    const outputDir = path.resolve(options.output);
+    
+    // Check if directory exists
+    try {
+      await fs.access(outputDir);
+      spinner.fail(`Directory ${outputDir} already exists`);
+      return;
+    } catch {
+      // Directory doesn't exist, good
+    }
+
+    // Create output directory
+    await fs.mkdir(outputDir, { recursive: true });
+
+    switch (type) {
+      case 'express':
+        await createExpressBackend(outputDir, options);
+        break;
+      case 'firebase':
+        await createFirebaseBackend(outputDir, options);
+        break;
+      case 'vercel':
+        await createVercelBackend(outputDir, options);
+        break;
+      default:
+        throw new Error(`Unknown backend type: ${type}`);
+    }
+
+    spinner.succeed(`${type} backend created successfully!`);
+    
+    console.log('');
+    console.log(chalk.bold('Next steps:'));
+    console.log(chalk.gray(`  1. cd ${options.output}`));
+    console.log(chalk.gray(`  2. npm install`));
+    console.log(chalk.gray(`  3. Configure your environment variables`));
+    console.log(chalk.gray(`  4. npm run dev`));
+
+  } catch (error) {
+    spinner.fail(`Failed to create backend: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+async function createExpressBackend(outputDir, options) {
+  // Create package.json
+  const packageJson = {
+    name: "native-update-backend",
+    version: "1.0.0",
+    description: "Native Update backend server",
+    type: "module",
+    scripts: {
+      dev: "node --watch server.js",
+      start: "node server.js",
+      test: "vitest"
+    },
+    dependencies: {
+      express: "^5.1.0",
+      cors: "^2.8.5",
+      "express-rate-limit": "^7.4.1",
+      multer: "^1.4.5-lts.1",
+      dotenv: "^16.4.7",
+      jsonwebtoken: "^9.0.2",
+      bcrypt: "^5.1.1"
+    }
+  };
+
+  if (options.withMonitoring) {
+    packageJson.dependencies["@opentelemetry/api"] = "^1.9.0";
+    packageJson.dependencies["@opentelemetry/sdk-node"] = "^0.57.0";
+    packageJson.dependencies["winston"] = "^3.17.1";
+  }
+
+  await fs.writeFile(
+    path.join(outputDir, 'package.json'),
+    JSON.stringify(packageJson, null, 2)
+  );
+
+  // Create server.js
+  const serverCode = `import express from 'express';
+import cors from 'cors';
+import dotenv from 'dotenv';
+import { router as bundleRouter } from './routes/bundles.js';
+import { router as authRouter } from './routes/auth.js';
+${options.withMonitoring ? "import { initMonitoring } from './monitoring/index.js';" : ''}
+
+dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+${options.withMonitoring ? 'initMonitoring(app);' : ''}
+
+app.use(cors());
+app.use(express.json());
+
+// Routes
+app.use('/api/bundles', bundleRouter);
+app.use('/api/auth', authRouter);
+
+// Health check
+app.get('/health', (req, res) => {
+  res.json({ status: 'ok', timestamp: new Date().toISOString() });
+});
+
+app.listen(PORT, () => {
+  console.log(\`Server running on port \${PORT}\`);
+});
+`;
+
+  await fs.writeFile(path.join(outputDir, 'server.js'), serverCode);
+
+  // Create routes directory
+  await fs.mkdir(path.join(outputDir, 'routes'), { recursive: true });
+
+  // Create bundles route
+  const bundlesRoute = `import express from 'express';
+import multer from 'multer';
+import path from 'path';
+import fs from 'fs/promises';
+import crypto from 'crypto';
+
+const router = express.Router();
+const upload = multer({ dest: 'uploads/' });
+
+// Get latest bundle
+router.get('/latest', async (req, res) => {
+  try {
+    const { appId, version, channel = 'production' } = req.query;
+    
+    // TODO: Implement bundle lookup logic
+    // This is a simplified example
+    const bundle = {
+      version: '1.0.1',
+      url: \`\${req.protocol}://\${req.get('host')}/bundles/latest.zip\`,
+      checksum: 'sha256:...',
+      signature: 'signature...',
+      metadata: {
+        releaseNotes: 'Bug fixes and improvements'
+      }
+    };
+    
+    res.json(bundle);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Upload new bundle
+router.post('/upload', upload.single('bundle'), async (req, res) => {
+  try {
+    const { version, channel, metadata } = req.body;
+    const file = req.file;
+    
+    if (!file) {
+      return res.status(400).json({ error: 'No bundle file provided' });
+    }
+    
+    // Calculate checksum
+    const fileBuffer = await fs.readFile(file.path);
+    const checksum = crypto.createHash('sha256').update(fileBuffer).digest('hex');
+    
+    // TODO: Store bundle metadata in database
+    // TODO: Move file to permanent storage
+    
+    res.json({
+      success: true,
+      bundle: {
+        version,
+        channel,
+        checksum,
+        size: file.size
+      }
+    });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+export { router };
+`;
+
+  await fs.writeFile(path.join(outputDir, 'routes', 'bundles.js'), bundlesRoute);
+
+  // Create .env.example
+  const envExample = `# Server Configuration
+PORT=3000
+
+# Security
+JWT_SECRET=your-secret-key-here
+API_KEY=your-api-key-here
+
+# Storage
+STORAGE_PATH=./storage/bundles
+
+# Database (optional)
+# DATABASE_URL=postgresql://user:password@localhost:5432/native_update
+`;
+
+  await fs.writeFile(path.join(outputDir, '.env.example'), envExample);
+
+  // Create README
+  const readme = `# Native Update Backend
+
+Express.js backend for Native Update plugin.
+
+## Setup
+
+1. Copy \`.env.example\` to \`.env\` and configure
+2. Run \`npm install\`
+3. Run \`npm run dev\` for development
+
+## API Endpoints
+
+- GET /api/bundles/latest - Get latest bundle for app
+- POST /api/bundles/upload - Upload new bundle
+- GET /health - Health check
+
+## Security
+
+- Uses JWT for authentication
+- Rate limiting enabled
+- CORS configured
+
+${options.withMonitoring ? '## Monitoring\n\nOpenTelemetry monitoring is configured. Set up your preferred backend (Jaeger, Zipkin, etc.)' : ''}
+`;
+
+  await fs.writeFile(path.join(outputDir, 'README.md'), readme);
+}
+
+async function createVercelBackend(outputDir, options) {
+  // Create api directory
+  const apiDir = path.join(outputDir, 'api');
+  await fs.mkdir(apiDir, { recursive: true });
+
+  // Create package.json
+  const packageJson = {
+    name: "native-update-vercel",
+    version: "1.0.0",
+    description: "Native Update Vercel backend",
+    type: "module",
+    scripts: {
+      dev: "vercel dev",
+      deploy: "vercel",
+      build: "echo 'No build step required'"
+    },
+    dependencies: {
+      "@vercel/node": "^3.0.0"
+    }
+  };
+
+  await fs.writeFile(
+    path.join(outputDir, 'package.json'),
+    JSON.stringify(packageJson, null, 2)
+  );
+
+  // Create bundles API endpoint
+  const bundlesApi = `export default async function handler(req, res) {
+  // Enable CORS
+  res.setHeader('Access-Control-Allow-Credentials', true);
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET,OPTIONS,PATCH,DELETE,POST,PUT');
+  res.setHeader(
+    'Access-Control-Allow-Headers',
+    'X-CSRF-Token, X-Requested-With, Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, X-Api-Version'
+  );
+
+  if (req.method === 'OPTIONS') {
+    res.status(200).end();
+    return;
+  }
+
+  if (req.method === 'GET') {
+    // Get latest bundle
+    const { appId, version, channel = 'production' } = req.query;
+    
+    // TODO: Implement bundle lookup from your storage solution
+    // This is a simplified example
+    const bundle = {
+      version: '1.0.1',
+      url: \`https://\${req.headers.host}/bundles/latest.zip\`,
+      checksum: 'sha256:...',
+      signature: 'signature...',
+      metadata: {
+        releaseNotes: 'Bug fixes and improvements'
+      }
+    };
+    
+    return res.status(200).json(bundle);
+  }
+
+  if (req.method === 'POST') {
+    // Handle bundle upload
+    const { version, channel, metadata } = req.body;
+    
+    // TODO: Handle file upload to storage (Vercel Blob, S3, etc.)
+    // TODO: Save metadata to database (Vercel KV, external DB, etc.)
+    
+    return res.status(200).json({
+      success: true,
+      bundle: {
+        version,
+        channel,
+        message: 'Bundle uploaded successfully'
+      }
+    });
+  }
+
+  return res.status(405).json({ error: 'Method not allowed' });
+}`;
+
+  await fs.writeFile(path.join(apiDir, 'bundles.js'), bundlesApi);
+
+  // Create health check endpoint
+  const healthApi = `export default function handler(req, res) {
+  res.status(200).json({
+    status: 'ok',
+    service: 'vercel-edge',
+    timestamp: new Date().toISOString()
+  });
+}`;
+
+  await fs.writeFile(path.join(apiDir, 'health.js'), healthApi);
+
+  // Create vercel.json
+  const vercelConfig = {
+    functions: {
+      "api/*.js": {
+        maxDuration: 30
+      }
+    },
+    rewrites: [
+      {
+        source: "/api/bundles/latest",
+        destination: "/api/bundles"
+      }
+    ]
+  };
+
+  await fs.writeFile(
+    path.join(outputDir, 'vercel.json'),
+    JSON.stringify(vercelConfig, null, 2)
+  );
+
+  // Create .env.example
+  const envExample = `# Storage Configuration
+STORAGE_URL=your-storage-url
+STORAGE_KEY=your-storage-key
+
+# Database Configuration (optional)
+DATABASE_URL=your-database-url
+
+# Security
+API_KEY=your-api-key-here
+`;
+
+  await fs.writeFile(path.join(outputDir, '.env.example'), envExample);
+
+  // Create README
+  const readme = `# Native Update Vercel Backend
+
+Serverless backend for Native Update plugin using Vercel Edge Functions.
+
+## Setup
+
+1. Install Vercel CLI: \`npm i -g vercel\`
+2. Copy \`.env.example\` to \`.env.local\` and configure
+3. Run \`npm install\`
+4. Run \`vercel dev\` for local development
+
+## Deployment
+
+\`\`\`bash
+vercel
+\`\`\`
+
+## API Endpoints
+
+- GET /api/bundles - Get latest bundle
+- POST /api/bundles - Upload new bundle
+- GET /api/health - Health check
+
+## Storage Options
+
+- Vercel Blob Storage
+- AWS S3
+- Cloudflare R2
+- Any S3-compatible storage
+
+## Database Options
+
+- Vercel KV
+- Vercel Postgres
+- PlanetScale
+- Supabase
+
+${options.withMonitoring ? '## Monitoring\\n\\nUse Vercel Analytics and Logs for monitoring.' : ''}
+`;
+
+  await fs.writeFile(path.join(outputDir, 'README.md'), readme);
+}
+
+async function createFirebaseBackend(outputDir, options) {
+  // Create functions directory
+  const functionsDir = path.join(outputDir, 'functions');
+  await fs.mkdir(functionsDir, { recursive: true });
+
+  // Create package.json for functions
+  const packageJson = {
+    name: "native-update-firebase-functions",
+    description: "Firebase Functions backend for Native Update",
+    type: "module",
+    engines: {
+      node: "22"
+    },
+    main: "index.js",
+    scripts: {
+      serve: "firebase emulators:start --only functions",
+      shell: "firebase functions:shell",
+      start: "npm run serve",
+      deploy: "firebase deploy --only functions",
+      logs: "firebase functions:log"
+    },
+    dependencies: {
+      "firebase-admin": "^12.0.0",
+      "firebase-functions": "^5.0.0",
+      cors: "^2.8.5",
+      "express": "^5.1.0"
+    }
+  };
+
+  await fs.writeFile(
+    path.join(functionsDir, 'package.json'),
+    JSON.stringify(packageJson, null, 2)
+  );
+
+  // Create index.js
+  const indexJs = `import { onRequest } from 'firebase-functions/v2/https';
+import * as admin from 'firebase-admin';
+import express from 'express';
+import cors from 'cors';
+
+admin.initializeApp();
+
+const app = express();
+app.use(cors({ origin: true }));
+app.use(express.json());
+
+// Get latest bundle
+app.get('/api/bundles/latest', async (req, res) => {
+  try {
+    const { appId, version, channel = 'production' } = req.query;
+    
+    // Query Firestore for latest bundle
+    const db = admin.firestore();
+    const snapshot = await db.collection('bundles')
+      .where('appId', '==', appId)
+      .where('channel', '==', channel)
+      .where('enabled', '==', true)
+      .orderBy('createdAt', 'desc')
+      .limit(1)
+      .get();
+    
+    if (snapshot.empty) {
+      return res.status(404).json({ error: 'No bundle found' });
+    }
+    
+    const bundle = snapshot.docs[0].data();
+    res.json(bundle);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Upload bundle
+app.post('/api/bundles/upload', async (req, res) => {
+  try {
+    const { version, channel, metadata } = req.body;
+    
+    // TODO: Handle file upload to Cloud Storage
+    // TODO: Save metadata to Firestore
+    
+    res.json({ success: true, version });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Health check
+app.get('/health', (req, res) => {
+  res.json({ status: 'ok', service: 'firebase-functions' });
+});
+
+export const api = onRequest(app);
+`;
+
+  await fs.writeFile(path.join(functionsDir, 'index.js'), indexJs);
+
+  // Create firebase.json
+  const firebaseConfig = {
+    functions: {
+      source: "functions",
+      runtime: "nodejs22"
+    },
+    firestore: {
+      rules: "firestore.rules",
+      indexes: "firestore.indexes.json"
+    },
+    storage: {
+      rules: "storage.rules"
+    }
+  };
+
+  await fs.writeFile(
+    path.join(outputDir, 'firebase.json'),
+    JSON.stringify(firebaseConfig, null, 2)
+  );
+
+  // Create Firestore rules
+  const firestoreRules = `rules_version = '2';
+service cloud.firestore {
+  match /databases/{database}/documents {
+    // Bundles are read-only for clients
+    match /bundles/{document=**} {
+      allow read: if true;
+      allow write: if false;
+    }
+    
+    // Analytics can be written by clients
+    match /analytics/{document=**} {
+      allow create: if true;
+      allow read, update, delete: if false;
+    }
+  }
+}`;
+
+  await fs.writeFile(path.join(outputDir, 'firestore.rules'), firestoreRules);
+
+  // Create README
+  const readme = `# Native Update Firebase Backend
+
+Firebase Functions backend for Native Update plugin.
+
+## Setup
+
+1. Install Firebase CLI: \`npm install -g firebase-tools\`
+2. Login: \`firebase login\`
+3. Initialize: \`firebase init\`
+4. Select your project or create new
+5. Install dependencies: \`cd functions && npm install\`
+6. Start emulator: \`npm run serve\`
+
+## Deployment
+
+\`\`\`bash
+firebase deploy
+\`\`\`
+
+## Endpoints
+
+- GET /api/bundles/latest - Get latest bundle
+- POST /api/bundles/upload - Upload new bundle
+- GET /health - Health check
+
+${options.withMonitoring ? '## Monitoring\n\nUse Firebase Console for monitoring and analytics.' : ''}
+`;
+
+  await fs.writeFile(path.join(outputDir, 'README.md'), readme);
+}

package/cli/commands/bundle-create.js

@@ -0,0 +1,113 @@
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+import archiver from 'archiver';
+import { createWriteStream } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export async function createBundle(webDir, options) {
+  console.log(chalk.blue('🔨 Creating update bundle...'));
+
+  try {
+    // Validate input directory
+    const stats = await fs.stat(webDir);
+    if (!stats.isDirectory()) {
+      throw new Error(`${webDir} is not a directory`);
+    }
+
+    // Check for index.html
+    const indexPath = path.join(webDir, 'index.html');
+    try {
+      await fs.access(indexPath);
+    } catch {
+      throw new Error(`No index.html found in ${webDir}. Is this a valid web build directory?`);
+    }
+
+    // Create output directory
+    const outputDir = path.resolve(options.output);
+    await fs.mkdir(outputDir, { recursive: true });
+
+    // Get version
+    let version = options.version;
+    if (!version) {
+      try {
+        const packageJsonPath = path.join(process.cwd(), 'package.json');
+        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+        version = packageJson.version;
+      } catch {
+        version = new Date().toISOString().split('T')[0].replace(/-/g, '.');
+      }
+    }
+
+    // Create bundle metadata
+    const metadata = {
+      version,
+      channel: options.channel,
+      created: new Date().toISOString(),
+      platform: 'web',
+      ...(options.metadata ? JSON.parse(options.metadata) : {})
+    };
+
+    const bundleId = `${version}-${Date.now()}`;
+    const bundleFileName = `bundle-${bundleId}.zip`;
+    const bundlePath = path.join(outputDir, bundleFileName);
+    const metadataPath = path.join(outputDir, `bundle-${bundleId}.json`);
+
+    console.log(chalk.gray(`  Version: ${version}`));
+    console.log(chalk.gray(`  Channel: ${options.channel}`));
+    console.log(chalk.gray(`  Output: ${bundlePath}`));
+
+    // Create zip archive
+    const output = createWriteStream(bundlePath);
+    const archive = archiver('zip', {
+      zlib: { level: 9 }
+    });
+
+    const archivePromise = new Promise((resolve, reject) => {
+      output.on('close', resolve);
+      archive.on('error', reject);
+    });
+
+    archive.pipe(output);
+
+    // Add all files from web directory
+    archive.directory(webDir, false);
+
+    await archive.finalize();
+    await archivePromise;
+
+    // Calculate checksum
+    const fileBuffer = await fs.readFile(bundlePath);
+    const checksum = crypto.createHash('sha256').update(fileBuffer).digest('hex');
+
+    // Update metadata with file info
+    metadata.checksum = checksum;
+    metadata.size = fileBuffer.length;
+    metadata.filename = bundleFileName;
+
+    // Save metadata
+    await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+
+    console.log(chalk.green('✅ Bundle created successfully!'));
+    console.log('');
+    console.log(chalk.bold('Bundle Details:'));
+    console.log(chalk.gray(`  File: ${bundlePath}`));
+    console.log(chalk.gray(`  Size: ${(fileBuffer.length / 1024 / 1024).toFixed(2)} MB`));
+    console.log(chalk.gray(`  Checksum: ${checksum}`));
+    console.log(chalk.gray(`  Metadata: ${metadataPath}`));
+    console.log('');
+    console.log(chalk.yellow('Next steps:'));
+    console.log(chalk.gray('  1. Sign the bundle:'));
+    console.log(chalk.cyan(`     npx native-update bundle sign ${bundlePath} --key ./keys/private.pem`));
+    console.log(chalk.gray('  2. Upload to your update server'));
+
+  } catch (error) {
+    console.error(chalk.red('❌ Failed to create bundle:'), error.message);
+    process.exit(1);
+  }
+}