npm - bgit-cli - Versions diffs - 2.0.0 - Mend

bgit-cli 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

package/.claude/settings.local.json +19 -0
package/.env.local +2 -0
package/CLAUDE_PLAN.md +621 -0
package/IMPLEMENTATION_REPORT.md +1690 -0
package/README.md +277 -0
package/UNIVERSAL_PLAN.md +31 -0
package/handcash.js +36 -0
package/index.js +158 -0
package/index.js.backup +69 -0
package/lib/auth.js +273 -0
package/lib/banner.js +17 -0
package/lib/command-router.js +191 -0
package/lib/commands.js +157 -0
package/lib/config.js +438 -0
package/lib/constants.js +57 -0
package/lib/crypto.js +164 -0
package/lib/oauth-server.js +300 -0
package/lib/payment.js +287 -0
package/lib/token-manager.js +179 -0
package/package.json +45 -0

package/lib/oauth-server.js ADDED Viewed

@@ -0,0 +1,300 @@
+/**
+ * bgit OAuth Callback Server
+ *
+ * Temporary local HTTP server for capturing HandCash OAuth callbacks.
+ * Runs on localhost:3000-3010 with 5-minute timeout.
+ *
+ * Features:
+ * - Automatic port conflict resolution (tries 3000-3010)
+ * - Timeout handling (5 minutes)
+ * - Graceful shutdown after token capture
+ * - User-friendly success/error pages
+ */
+const express = require('express');
+const http = require('http');
+const {
+  OAUTH_PORT_START,
+  OAUTH_PORT_END,
+  OAUTH_TIMEOUT_MS,
+  OAUTH_HOST
+} = require('./constants');
+/**
+ * Start temporary OAuth callback server
+ *
+ * @param {number} startPort - First port to try (default: 3000)
+ * @param {number} endPort - Last port to try (default: 3010)
+ * @returns {Promise<{authToken: string, port: number, server: http.Server}>}
+ * @throws {Error} If all ports are in use or timeout occurs
+ */
+async function startOAuthServer(startPort = OAUTH_PORT_START, endPort = OAUTH_PORT_END) {
+  const app = express();
+  let server;
+  let actualPort;
+  let resolveToken;
+  let rejectToken;
+  // Create promise for token capture
+  const tokenPromise = new Promise((resolve, reject) => {
+    resolveToken = resolve;
+    rejectToken = reject;
+    // Set timeout (5 minutes)
+    setTimeout(() => {
+      reject(new Error('OAuth timeout: No authorization received within 5 minutes'));
+    }, OAUTH_TIMEOUT_MS);
+  });
+  // Success callback route
+  app.get('/callback', (req, res) => {
+    const { authToken } = req.query;
+    if (authToken) {
+      res.send(`
+        <!DOCTYPE html>
+        <html>
+        <head>
+          <title>bgit Authentication Successful</title>
+          <style>
+            body {
+              font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+              display: flex;
+              justify-content: center;
+              align-items: center;
+              height: 100vh;
+              margin: 0;
+              background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            }
+            .container {
+              background: white;
+              padding: 3rem;
+              border-radius: 10px;
+              box-shadow: 0 10px 40px rgba(0,0,0,0.2);
+              text-align: center;
+              max-width: 400px;
+            }
+            h1 {
+              color: #2d3748;
+              margin-bottom: 1rem;
+            }
+            .success-icon {
+              font-size: 4rem;
+              margin-bottom: 1rem;
+            }
+            p {
+              color: #4a5568;
+              line-height: 1.6;
+            }
+            .close-hint {
+              margin-top: 2rem;
+              font-size: 0.875rem;
+              color: #718096;
+            }
+          </style>
+        </head>
+        <body>
+          <div class="container">
+            <div class="success-icon">✅</div>
+            <h1>Authentication Successful!</h1>
+            <p>Your HandCash wallet has been connected to bgit.</p>
+            <p>You can now close this window and return to your terminal.</p>
+            <div class="close-hint">This window will close automatically in 5 seconds...</div>
+          </div>
+          <script>
+            setTimeout(() => window.close(), 5000);
+          </script>
+        </body>
+        </html>
+      `);
+      // Resolve with token
+      resolveToken({ authToken, port: actualPort, server });
+    } else {
+      res.status(400).send(`
+        <!DOCTYPE html>
+        <html>
+        <head>
+          <title>bgit Authentication Failed</title>
+          <style>
+            body {
+              font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+              display: flex;
+              justify-content: center;
+              align-items: center;
+              height: 100vh;
+              margin: 0;
+              background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+            }
+            .container {
+              background: white;
+              padding: 3rem;
+              border-radius: 10px;
+              box-shadow: 0 10px 40px rgba(0,0,0,0.2);
+              text-align: center;
+              max-width: 400px;
+            }
+            h1 {
+              color: #2d3748;
+              margin-bottom: 1rem;
+            }
+            .error-icon {
+              font-size: 4rem;
+              margin-bottom: 1rem;
+            }
+            p {
+              color: #4a5568;
+              line-height: 1.6;
+            }
+          </style>
+        </head>
+        <body>
+          <div class="container">
+            <div class="error-icon">❌</div>
+            <h1>Authentication Failed</h1>
+            <p>No authorization token received from HandCash.</p>
+            <p>Please try again by running: <code>bgit auth login</code></p>
+          </div>
+        </body>
+        </html>
+      `);
+      rejectToken(new Error('No auth token received in callback'));
+    }
+  });
+  // Error callback route
+  app.get('/error', (req, res) => {
+    const { message } = req.query;
+    res.status(400).send(`
+      <!DOCTYPE html>
+      <html>
+      <head>
+        <title>bgit Authentication Error</title>
+        <style>
+          body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            height: 100vh;
+            margin: 0;
+            background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+          }
+          .container {
+            background: white;
+            padding: 3rem;
+            border-radius: 10px;
+            box-shadow: 0 10px 40px rgba(0,0,0,0.2);
+            text-align: center;
+            max-width: 400px;
+          }
+          h1 {
+            color: #2d3748;
+            margin-bottom: 1rem;
+          }
+          .error-icon {
+            font-size: 4rem;
+            margin-bottom: 1rem;
+          }
+          p {
+            color: #4a5568;
+            line-height: 1.6;
+          }
+          .error-message {
+            background: #fed7d7;
+            padding: 1rem;
+            border-radius: 5px;
+            margin-top: 1rem;
+            color: #c53030;
+          }
+        </style>
+      </head>
+      <body>
+        <div class="container">
+          <div class="error-icon">⚠️</div>
+          <h1>Authentication Error</h1>
+          <p>An error occurred during authentication:</p>
+          <div class="error-message">${message || 'Unknown error'}</div>
+          <p style="margin-top: 2rem;">Please try again by running: <code>bgit auth login</code></p>
+        </div>
+      </body>
+      </html>
+    `);
+    rejectToken(new Error(`OAuth error: ${message || 'Unknown error'}`));
+  });
+  // Health check route
+  app.get('/health', (req, res) => {
+    res.send('OK');
+  });
+  // Try to start server on available port
+  for (let port = startPort; port <= endPort; port++) {
+    try {
+      server = await new Promise((resolve, reject) => {
+        const srv = http.createServer(app);
+        srv.listen(port, OAUTH_HOST, () => {
+          actualPort = port;
+          resolve(srv);
+        });
+        srv.on('error', (err) => {
+          if (err.code === 'EADDRINUSE') {
+            resolve(null); // Try next port
+          } else {
+            reject(err);
+          }
+        });
+      });
+      if (server) {
+        console.log(`OAuth server started on http://${OAUTH_HOST}:${actualPort}`);
+        break; // Successfully started
+      }
+    } catch (error) {
+      throw new Error(`Failed to start OAuth server: ${error.message}`);
+    }
+  }
+  if (!server) {
+    throw new Error(`All ports (${startPort}-${endPort}) are in use. Please free up a port and try again.`);
+  }
+  // Wait for token or timeout
+  const result = await tokenPromise;
+  return result;
+}
+/**
+ * Stop OAuth server
+ *
+ * @param {http.Server} server - Server instance to stop
+ * @returns {Promise<void>}
+ */
+function stopOAuthServer(server) {
+  return new Promise((resolve, reject) => {
+    if (!server) {
+      resolve();
+      return;
+    }
+    server.close((err) => {
+      if (err) {
+        reject(new Error(`Failed to stop OAuth server: ${err.message}`));
+      } else {
+        console.log('OAuth server stopped');
+        resolve();
+      }
+    });
+  });
+}
+module.exports = {
+  startOAuthServer,
+  stopOAuthServer
+};

package/lib/payment.js ADDED Viewed

@@ -0,0 +1,287 @@
+/**
+ * bgit Payment Gateway
+ *
+ * Handles BitcoinSV payments via HandCash for commit timestamps and pushes.
+ * Enhanced with retry logic, error handling, and user-friendly messages.
+ *
+ * Features:
+ * - Automatic retry with exponential backoff
+ * - Pre-flight balance check (optional)
+ * - Enhanced error messages
+ * - Transaction logging
+ * - Soft fail for git operations (git succeeds even if payment fails)
+ */
+const { HandCashConnect } = require('@handcash/handcash-connect');
+const chalk = require('chalk');
+const {
+  HANDCASH_APP_ID,
+  HANDCASH_APP_SECRET,
+  TREASURY_HANDLE,
+  PAYMENT_RETRY_MAX_ATTEMPTS,
+  PAYMENT_RETRY_BASE_DELAY_MS,
+  PAYMENT_RETRY_MAX_DELAY_MS
+} = require('./constants');
+/**
+ * Sleep for specified milliseconds
+ * @param {number} ms - Milliseconds to sleep
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Calculate exponential backoff delay
+ * @param {number} attempt - Current attempt number (0-indexed)
+ * @returns {number} Delay in milliseconds
+ */
+function getBackoffDelay(attempt) {
+  const delay = PAYMENT_RETRY_BASE_DELAY_MS * Math.pow(2, attempt);
+  return Math.min(delay, PAYMENT_RETRY_MAX_DELAY_MS);
+}
+/**
+ * Execute payment with retry logic
+ *
+ * @param {number} amount - Amount in BSV
+ * @param {string} note - Payment description/note (e.g., "Commit: abc123")
+ * @param {string} authToken - HandCash auth token
+ * @param {Object} options - Additional options
+ * @param {boolean} options.checkBalance - Whether to check balance before payment (default: false)
+ * @param {number} options.maxRetries - Max retry attempts (default: 3)
+ * @returns {Promise<Object>} Payment result with transactionId
+ * @throws {Error} If payment fails after all retries
+ */
+async function executePayment(amount, note, authToken, options = {}) {
+  const {
+    checkBalance = false,
+    maxRetries = PAYMENT_RETRY_MAX_ATTEMPTS
+  } = options;
+  if (!authToken) {
+    throw new Error('Auth token is required for payment');
+  }
+  if (!amount || amount <= 0) {
+    throw new Error('Payment amount must be greater than 0');
+  }
+  try {
+    const handCashConnect = new HandCashConnect({
+      appId: HANDCASH_APP_ID,
+      appSecret: HANDCASH_APP_SECRET
+    });
+    const account = handCashConnect.getAccountFromAuthToken(authToken);
+    // Optional: Pre-flight balance check
+    if (checkBalance) {
+      try {
+        const balance = await account.wallet.getSpendableBalance();
+        if (balance.bsv < amount) {
+          throw new Error(
+            `Insufficient balance. You have ${balance.bsv.toFixed(6)} BSV, but need ${amount} BSV.\n` +
+            `Add funds at: ${chalk.cyan('https://handcash.io')}`
+          );
+        }
+      } catch (balanceError) {
+        // Don't fail payment if balance check fails, just warn
+        console.warn(chalk.yellow(`Warning: Could not check balance - ${balanceError.message}`));
+      }
+    }
+    // Payment parameters
+    const paymentParameters = {
+      description: note || 'bgit payment',
+      payments: [
+        {
+          destination: TREASURY_HANDLE,
+          currencyCode: 'BSV',
+          sendAmount: amount
+        }
+      ]
+    };
+    // Retry logic with exponential backoff
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        const result = await account.wallet.pay(paymentParameters);
+        // Payment successful
+        console.log(chalk.green(`✓ Payment sent! Transaction ID: ${result.transactionId}`));
+        if (note) {
+          console.log(chalk.gray(`  Note: ${note}`));
+        }
+        return result;
+      } catch (error) {
+        lastError = error;
+        // Check if error is retryable
+        const isRetryable = isRetryableError(error);
+        if (!isRetryable || attempt === maxRetries - 1) {
+          // Don't retry, throw error
+          break;
+        }
+        // Retry with backoff
+        const delay = getBackoffDelay(attempt);
+        console.log(chalk.yellow(`⚠️  Payment attempt ${attempt + 1} failed, retrying in ${delay / 1000}s... (${attempt + 1}/${maxRetries})`));
+        await sleep(delay);
+      }
+    }
+    // All retries failed
+    throw enhancePaymentError(lastError);
+  } catch (error) {
+    throw error;
+  }
+}
+/**
+ * Check if error is retryable
+ * Network errors and timeouts are retryable
+ * Insufficient balance and invalid tokens are not
+ *
+ * @param {Error} error - Error to check
+ * @returns {boolean} true if error is retryable
+ */
+function isRetryableError(error) {
+  const message = error.message.toLowerCase();
+  // Retryable errors
+  const retryableKeywords = [
+    'network',
+    'timeout',
+    'econnrefused',
+    'enotfound',
+    'etimedout',
+    'socket hang up'
+  ];
+  if (retryableKeywords.some(keyword => message.includes(keyword))) {
+    return true;
+  }
+  // Non-retryable errors
+  const nonRetryableKeywords = [
+    'insufficient',
+    'balance',
+    'invalid token',
+    'unauthorized',
+    'forbidden'
+  ];
+  if (nonRetryableKeywords.some(keyword => message.includes(keyword))) {
+    return false;
+  }
+  // Default: retry unknown errors
+  return true;
+}
+/**
+ * Enhance payment error with helpful user message
+ *
+ * @param {Error} error - Original error
+ * @returns {Error} Enhanced error with user-friendly message
+ */
+function enhancePaymentError(error) {
+  const message = error.message.toLowerCase();
+  // Insufficient balance
+  if (message.includes('insufficient') || message.includes('balance')) {
+    return new Error(
+      `Insufficient balance in your HandCash wallet.\n` +
+      `Add funds at: ${chalk.cyan('https://handcash.io')}\n` +
+      `Original error: ${error.message}`
+    );
+  }
+  // Invalid auth
+  if (message.includes('unauthorized') || message.includes('invalid token')) {
+    return new Error(
+      `Your authentication has expired.\n` +
+      `Please run: ${chalk.cyan('bgit auth login')}\n` +
+      `Original error: ${error.message}`
+    );
+  }
+  // Network errors
+  if (message.includes('network') || message.includes('timeout')) {
+    return new Error(
+      `Network error - please check your internet connection and try again.\n` +
+      `Original error: ${error.message}`
+    );
+  }
+  // API errors
+  if (message.includes('api') || message.includes('handcash')) {
+    return new Error(
+      `HandCash API error - the service may be temporarily unavailable.\n` +
+      `Please try again later.\n` +
+      `Original error: ${error.message}`
+    );
+  }
+  // Unknown error
+  return new Error(`Payment failed: ${error.message}`);
+}
+/**
+ * Format payment note for commit timestamp
+ *
+ * @param {string} commitHash - Git commit hash
+ * @returns {string} Formatted note
+ */
+function formatCommitNote(commitHash) {
+  return `bgit commit: ${commitHash}`;
+}
+/**
+ * Format payment note for push
+ *
+ * @param {string} remote - Remote name (e.g., "origin")
+ * @param {string} branch - Branch name (e.g., "main")
+ * @returns {string} Formatted note
+ */
+function formatPushNote(remote = 'origin', branch = 'main') {
+  return `bgit push: ${remote}/${branch}`;
+}
+/**
+ * Soft fail wrapper for payments
+ * If payment fails, warn user but don't fail the git operation
+ *
+ * @param {Function} paymentFn - Payment function to execute
+ * @param {string} operation - Operation name (e.g., "commit", "push")
+ * @returns {Promise<boolean>} true if payment succeeded, false otherwise
+ */
+async function softFailPayment(paymentFn, operation) {
+  try {
+    await paymentFn();
+    return true;
+  } catch (error) {
+    console.warn(chalk.yellow(`\n⚠️  ${operation} succeeded, but on-chain timestamp failed:`));
+    console.warn(chalk.yellow(error.message));
+    console.log(chalk.gray(`Your ${operation} was saved locally.`));
+    console.log();
+    return false;
+  }
+}
+module.exports = {
+  executePayment,
+  formatCommitNote,
+  formatPushNote,
+  softFailPayment,
+  isRetryableError,
+  enhancePaymentError
+};