genbox 1.0.64 → 1.0.66

package/dist/utils/branch-prompt.js

@@ -0,0 +1,231 @@
+"use strict";
+/**
+ * Branch Prompt Utilities
+ * Shared functions for interactive branch selection
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptForBranchOptionsCreate = promptForBranchOptionsCreate;
+exports.promptForBranchOptionsRebuild = promptForBranchOptionsRebuild;
+const prompts = __importStar(require("@inquirer/prompts"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Prompt for branch options interactively (for create command)
+ * Default behavior: create new branch from configured default (or 'main') with branch name = environment name
+ */
+async function promptForBranchOptionsCreate(resolved, config, envName) {
+    // Get the default/base branch from config (used as source for new branches)
+    const baseBranch = config.defaults?.branch || 'main';
+    console.log(chalk_1.default.blue('=== Branch Configuration ==='));
+    console.log('');
+    const branchChoice = await prompts.select({
+        message: 'Branch option:',
+        choices: [
+            {
+                name: `${chalk_1.default.green('Create new branch')} '${chalk_1.default.cyan(envName)}' from '${baseBranch}' ${chalk_1.default.dim('(recommended)')}`,
+                value: 'new-from-default',
+            },
+            {
+                name: `Create new branch from a different source`,
+                value: 'new-custom',
+            },
+            {
+                name: 'Use an existing branch',
+                value: 'existing',
+            },
+            {
+                name: `Use '${baseBranch}' directly without creating new branch`,
+                value: 'default',
+            },
+        ],
+        default: 'new-from-default',
+    });
+    if (branchChoice === 'new-from-default') {
+        // Create new branch from configured default with name = environment name
+        return {
+            ...resolved,
+            repos: resolved.repos.map(repo => ({
+                ...repo,
+                branch: envName,
+                newBranch: envName,
+                sourceBranch: baseBranch,
+            })),
+        };
+    }
+    if (branchChoice === 'new-custom') {
+        const newBranchName = await prompts.input({
+            message: 'New branch name:',
+            default: envName,
+            validate: (value) => {
+                if (!value.trim())
+                    return 'Branch name is required';
+                if (!/^[\w\-./]+$/.test(value))
+                    return 'Invalid branch name (use letters, numbers, -, _, /, .)';
+                return true;
+            },
+        });
+        const sourceBranch = await prompts.input({
+            message: 'Create from branch:',
+            default: 'main',
+            validate: (value) => {
+                if (!value.trim())
+                    return 'Source branch is required';
+                return true;
+            },
+        });
+        // Update all repos with new branch info
+        return {
+            ...resolved,
+            repos: resolved.repos.map(repo => ({
+                ...repo,
+                branch: newBranchName.trim(),
+                newBranch: newBranchName.trim(),
+                sourceBranch: sourceBranch.trim(),
+            })),
+        };
+    }
+    if (branchChoice === 'existing') {
+        const branchName = await prompts.input({
+            message: 'Enter branch name:',
+            default: baseBranch,
+            validate: (value) => {
+                if (!value.trim())
+                    return 'Branch name is required';
+                return true;
+            },
+        });
+        // Update all repos with the selected branch
+        return {
+            ...resolved,
+            repos: resolved.repos.map(repo => ({
+                ...repo,
+                branch: branchName.trim(),
+                newBranch: undefined,
+                sourceBranch: undefined,
+            })),
+        };
+    }
+    if (branchChoice === 'default') {
+        // Keep resolved repos as-is (no new branch)
+        return resolved;
+    }
+    return resolved;
+}
+/**
+ * Prompt for branch options interactively (for rebuild command)
+ * Simpler version - just switch branches or create new
+ */
+async function promptForBranchOptionsRebuild(resolved, config) {
+    // Get the default branch from config or first repo
+    const defaultBranch = config.defaults?.branch || resolved.repos[0]?.branch || 'main';
+    console.log(chalk_1.default.blue('=== Branch Configuration ==='));
+    console.log(chalk_1.default.dim(`Default branch: ${defaultBranch}`));
+    console.log('');
+    const branchChoice = await prompts.select({
+        message: 'Branch option:',
+        choices: [
+            {
+                name: `Use default branch (${defaultBranch})`,
+                value: 'default',
+            },
+            {
+                name: 'Use a different existing branch',
+                value: 'existing',
+            },
+            {
+                name: 'Create a new branch',
+                value: 'new',
+            },
+        ],
+        default: 'default',
+    });
+    if (branchChoice === 'default') {
+        return resolved;
+    }
+    if (branchChoice === 'existing') {
+        const branchName = await prompts.input({
+            message: 'Enter branch name:',
+            default: defaultBranch,
+            validate: (value) => {
+                if (!value.trim())
+                    return 'Branch name is required';
+                return true;
+            },
+        });
+        return {
+            ...resolved,
+            repos: resolved.repos.map(repo => ({
+                ...repo,
+                branch: branchName.trim(),
+                newBranch: undefined,
+                sourceBranch: undefined,
+            })),
+        };
+    }
+    if (branchChoice === 'new') {
+        const newBranchName = await prompts.input({
+            message: 'New branch name:',
+            validate: (value) => {
+                if (!value.trim())
+                    return 'Branch name is required';
+                if (!/^[\w\-./]+$/.test(value))
+                    return 'Invalid branch name (use letters, numbers, -, _, /, .)';
+                return true;
+            },
+        });
+        const sourceBranch = await prompts.input({
+            message: 'Create from branch:',
+            default: defaultBranch,
+            validate: (value) => {
+                if (!value.trim())
+                    return 'Source branch is required';
+                return true;
+            },
+        });
+        return {
+            ...resolved,
+            repos: resolved.repos.map(repo => ({
+                ...repo,
+                branch: newBranchName.trim(),
+                newBranch: newBranchName.trim(),
+                sourceBranch: sourceBranch.trim(),
+            })),
+        };
+    }
+    return resolved;
+}

package/dist/utils/env-parser.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * Environment File Parser Utilities
+ * Shared functions for parsing and processing .env.genbox files
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEnvGenboxSections = parseEnvGenboxSections;
+exports.buildServiceUrlMap = buildServiceUrlMap;
+exports.buildAppEnvContent = buildAppEnvContent;
+exports.parseEnvVarsFromSection = parseEnvVarsFromSection;
+/**
+ * Parse .env.genbox file into segregated sections
+ * Sections are marked with: # === SECTION_NAME ===
+ */
+function parseEnvGenboxSections(content) {
+    const sections = new Map();
+    let currentSection = 'GLOBAL';
+    let currentContent = [];
+    for (const line of content.split('\n')) {
+        const sectionMatch = line.match(/^# === ([^=]+) ===$/);
+        if (sectionMatch) {
+            // Save previous section
+            if (currentContent.length > 0) {
+                sections.set(currentSection, currentContent.join('\n').trim());
+            }
+            currentSection = sectionMatch[1].trim();
+            currentContent = [];
+        }
+        else if (currentSection !== 'END') {
+            currentContent.push(line);
+        }
+    }
+    // Save last section
+    if (currentContent.length > 0 && currentSection !== 'END') {
+        sections.set(currentSection, currentContent.join('\n').trim());
+    }
+    return sections;
+}
+/**
+ * Build a map of service URL variables based on connection type
+ * e.g., if connectTo=staging: GATEWAY_URL → STAGING_GATEWAY_URL value
+ */
+function buildServiceUrlMap(envVarsFromFile, connectTo) {
+    const urlMap = {};
+    const prefix = connectTo ? `${connectTo.toUpperCase()}_` : 'LOCAL_';
+    // Find all service URL variables (LOCAL_*_URL and STAGING_*_URL patterns)
+    const serviceNames = new Set();
+    for (const key of Object.keys(envVarsFromFile)) {
+        const match = key.match(/^(LOCAL|STAGING|PRODUCTION)_(.+_URL)$/);
+        if (match) {
+            serviceNames.add(match[2]);
+        }
+    }
+    // Build mapping: VARNAME → value from appropriate prefix
+    for (const serviceName of serviceNames) {
+        const prefixedKey = `${prefix}${serviceName}`;
+        const localKey = `LOCAL_${serviceName}`;
+        // Use prefixed value if available, otherwise fall back to local
+        const value = envVarsFromFile[prefixedKey] || envVarsFromFile[localKey];
+        if (value) {
+            urlMap[serviceName] = value;
+        }
+    }
+    // Also handle legacy API_URL for backwards compatibility
+    if (!urlMap['API_URL']) {
+        const apiUrl = envVarsFromFile[`${prefix}API_URL`] ||
+            envVarsFromFile['LOCAL_API_URL'] ||
+            envVarsFromFile['STAGING_API_URL'];
+        if (apiUrl) {
+            urlMap['API_URL'] = apiUrl;
+        }
+    }
+    return urlMap;
+}
+/**
+ * Build env content for a specific app by combining GLOBAL + app-specific sections
+ */
+function buildAppEnvContent(sections, appName, serviceUrlMap) {
+    const parts = [];
+    // Always include GLOBAL section
+    const globalSection = sections.get('GLOBAL');
+    if (globalSection) {
+        parts.push(globalSection);
+    }
+    // Include app-specific section if exists
+    const appSection = sections.get(appName);
+    if (appSection) {
+        parts.push(appSection);
+    }
+    let envContent = parts.join('\n\n');
+    // Expand all ${VARNAME} references using the service URL map
+    for (const [varName, value] of Object.entries(serviceUrlMap)) {
+        const pattern = new RegExp(`\\$\\{${varName}\\}`, 'g');
+        envContent = envContent.replace(pattern, value);
+    }
+    // Keep only actual env vars (filter out pure comment lines but keep var definitions)
+    envContent = envContent
+        .split('\n')
+        .filter(line => {
+        const trimmed = line.trim();
+        // Keep empty lines, lines with = (even if commented), and non-comment lines
+        return trimmed === '' || trimmed.includes('=') || !trimmed.startsWith('#');
+    })
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+    return envContent;
+}
+/**
+ * Parse env vars from a section content string
+ */
+function parseEnvVarsFromSection(sectionContent) {
+    const envVars = {};
+    for (const line of sectionContent.split('\n')) {
+        const match = line.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
+        if (match) {
+            let value = match[2].trim();
+            // Remove quotes if present
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+            envVars[match[1]] = value;
+        }
+    }
+    return envVars;
+}

package/dist/utils/git-utils.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Git Utilities
+ * Shared functions for git configuration and validation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateGitCredentials = validateGitCredentials;
+exports.getGitConfig = getGitConfig;
+const child_process_1 = require("child_process");
+/**
+ * Validate git configuration and warn about missing credentials
+ */
+function validateGitCredentials(repos, gitToken, privateKey) {
+    const warnings = [];
+    const errors = [];
+    for (const repo of repos) {
+        const isHttps = repo.url.startsWith('https://');
+        const isSsh = repo.url.startsWith('git@') || repo.url.includes('ssh://');
+        const isPrivateRepo = repo.url.includes('github.com') && !repo.url.includes('/public/');
+        if (isHttps && !gitToken && isPrivateRepo) {
+            warnings.push(`Repository '${repo.name}' uses HTTPS URL but GIT_TOKEN is not set.`);
+            warnings.push(`  Add GIT_TOKEN=<your-github-token> to .env.genbox for private repos.`);
+        }
+        if (isSsh && !privateKey) {
+            warnings.push(`Repository '${repo.name}' uses SSH URL but no SSH key was injected.`);
+        }
+    }
+    return { warnings, errors };
+}
+/**
+ * Get local git config for commits on genbox
+ */
+function getGitConfig() {
+    let userName;
+    let userEmail;
+    try {
+        userName = (0, child_process_1.execSync)('git config --global user.name', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        // Git config not set
+    }
+    try {
+        userEmail = (0, child_process_1.execSync)('git config --global user.email', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        // Git config not set
+    }
+    return { userName, userEmail };
+}

package/dist/utils/index.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Shared Utilities
+ * Re-exports all utility modules for convenient importing
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ssh-keys"), exports);
+__exportStar(require("./env-parser"), exports);
+__exportStar(require("./git-utils"), exports);
+__exportStar(require("./branch-prompt"), exports);

package/dist/utils/ssh-keys.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * SSH Key Utilities
+ * Shared functions for reading SSH keys
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPublicSshKey = getPublicSshKey;
+exports.getPrivateSshKey = getPrivateSshKey;
+exports.getPrivateSshKeyPath = getPrivateSshKeyPath;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+/**
+ * Get the public SSH key content
+ * Tries ed25519 first, then RSA
+ */
+function getPublicSshKey() {
+    const home = os.homedir();
+    const potentialKeys = [
+        path.join(home, '.ssh', 'id_ed25519.pub'),
+        path.join(home, '.ssh', 'id_rsa.pub'),
+    ];
+    for (const keyPath of potentialKeys) {
+        if (fs.existsSync(keyPath)) {
+            const content = fs.readFileSync(keyPath, 'utf-8').trim();
+            if (content)
+                return content;
+        }
+    }
+    throw new Error('No public SSH key found in ~/.ssh/');
+}
+/**
+ * Get the private SSH key content (for injection into remote server)
+ * Returns undefined if no key found
+ */
+function getPrivateSshKey() {
+    const home = os.homedir();
+    const potentialKeys = [
+        path.join(home, '.ssh', 'id_ed25519'),
+        path.join(home, '.ssh', 'id_rsa'),
+    ];
+    for (const keyPath of potentialKeys) {
+        if (fs.existsSync(keyPath)) {
+            return fs.readFileSync(keyPath, 'utf-8');
+        }
+    }
+    return undefined;
+}
+/**
+ * Get the path to the private SSH key (for local SSH commands)
+ * Throws if no key found
+ */
+function getPrivateSshKeyPath() {
+    const home = os.homedir();
+    const potentialKeys = [
+        path.join(home, '.ssh', 'id_ed25519'),
+        path.join(home, '.ssh', 'id_rsa'),
+    ];
+    for (const keyPath of potentialKeys) {
+        if (fs.existsSync(keyPath)) {
+            return keyPath;
+        }
+    }
+    throw new Error('No SSH private key found in ~/.ssh/');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genbox",
-  "version": "1.0.64",
+  "version": "1.0.66",
   "description": "Genbox CLI - AI-Powered Development Environments",
   "main": "dist/index.js",
   "bin": {