@iloom/cli 0.1.14

package/dist/chunk-HPJJSYNS.js

@@ -0,0 +1,644 @@
+#!/usr/bin/env node
+import {
+  calculatePortForBranch
+} from "./chunk-37DYYFVK.js";
+import {
+  runScript
+} from "./chunk-BLCTGFZN.js";
+import {
+  hasScript,
+  readPackageJson
+} from "./chunk-2ZPFJQ3B.js";
+import {
+  formatEnvLine,
+  parseEnvFile,
+  validateEnvVariable
+} from "./chunk-SJUQ2NDR.js";
+import {
+  createLogger,
+  logger
+} from "./chunk-GEHQXLEI.js";
+
+// src/lib/EnvironmentManager.ts
+import fs from "fs-extra";
+var logger2 = createLogger({ prefix: "\u{1F4DD}" });
+var EnvironmentManager = class {
+  constructor() {
+    this.backupSuffix = ".backup";
+  }
+  /**
+   * Set or update an environment variable in a .env file
+   * Ports functionality from bash/utils/env-utils.sh:setEnvVar()
+   * @returns The backup path if a backup was created
+   */
+  async setEnvVar(filePath, key, value, backup = false) {
+    const validation = validateEnvVariable(key, value);
+    if (!validation.valid) {
+      throw new Error(validation.error ?? "Invalid variable name");
+    }
+    const fileExists = await fs.pathExists(filePath);
+    if (!fileExists) {
+      logger2.info(`Creating ${filePath} with ${key}...`);
+      const content = formatEnvLine(key, value);
+      await fs.writeFile(filePath, content, "utf8");
+      logger2.success(`${filePath} created with ${key}`);
+      return;
+    }
+    const existingContent = await fs.readFile(filePath, "utf8");
+    const envMap = parseEnvFile(existingContent);
+    let backupPath;
+    if (backup) {
+      backupPath = await this.createBackup(filePath);
+    }
+    envMap.set(key, value);
+    const lines = existingContent.split("\n");
+    const newLines = [];
+    let variableUpdated = false;
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (!trimmedLine || trimmedLine.startsWith("#")) {
+        newLines.push(line);
+        continue;
+      }
+      const cleanLine = trimmedLine.startsWith("export ") ? trimmedLine.substring(7) : trimmedLine;
+      const equalsIndex = cleanLine.indexOf("=");
+      if (equalsIndex !== -1) {
+        const lineKey = cleanLine.substring(0, equalsIndex).trim();
+        if (lineKey === key) {
+          newLines.push(formatEnvLine(key, value));
+          variableUpdated = true;
+          continue;
+        }
+      }
+      newLines.push(line);
+    }
+    if (!variableUpdated) {
+      logger2.info(`Adding ${key} to ${filePath}...`);
+      newLines.push(formatEnvLine(key, value));
+      logger2.success(`${key} added successfully`);
+    } else {
+      logger2.info(`Updating ${key} in ${filePath}...`);
+      logger2.success(`${key} updated successfully`);
+    }
+    const newContent = newLines.join("\n");
+    await fs.writeFile(filePath, newContent, "utf8");
+    return backupPath;
+  }
+  /**
+   * Read and parse a .env file
+   */
+  async readEnvFile(filePath) {
+    try {
+      const content = await fs.readFile(filePath, "utf8");
+      return parseEnvFile(content);
+    } catch (error) {
+      logger2.debug(
+        `Could not read env file ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return /* @__PURE__ */ new Map();
+    }
+  }
+  /**
+   * Generic file copy helper that only copies if source exists
+   * Does not throw if source file doesn't exist - just logs and returns
+   * @private
+   */
+  async copyIfExists(source, destination) {
+    const sourceExists = await fs.pathExists(source);
+    if (!sourceExists) {
+      logger2.debug(`Source file ${source} does not exist, skipping copy`);
+      return;
+    }
+    await fs.copy(source, destination, { overwrite: false });
+    logger2.success(`Copied ${source} to ${destination}`);
+  }
+  /**
+   * Calculate unique port for workspace
+   * Implements:
+   * - Issue/PR: 3000 + issue/PR number
+   * - Branch: 3000 + deterministic hash offset (1-999)
+   */
+  calculatePort(options) {
+    const basePort = options.basePort ?? 3e3;
+    if (options.issueNumber !== void 0) {
+      const port = basePort + options.issueNumber;
+      if (port > 65535) {
+        throw new Error(
+          `Calculated port ${port} exceeds maximum (65535). Use a lower base port or issue number.`
+        );
+      }
+      return port;
+    }
+    if (options.prNumber !== void 0) {
+      const port = basePort + options.prNumber;
+      if (port > 65535) {
+        throw new Error(
+          `Calculated port ${port} exceeds maximum (65535). Use a lower base port or PR number.`
+        );
+      }
+      return port;
+    }
+    if (options.branchName !== void 0) {
+      return calculatePortForBranch(options.branchName, basePort);
+    }
+    return basePort;
+  }
+  /**
+   * Set port environment variable for workspace
+   */
+  async setPortForWorkspace(envFilePath, issueNumber, prNumber, branchName) {
+    const options = {};
+    if (issueNumber !== void 0) {
+      options.issueNumber = issueNumber;
+    }
+    if (prNumber !== void 0) {
+      options.prNumber = prNumber;
+    }
+    if (branchName !== void 0) {
+      options.branchName = branchName;
+    }
+    const port = this.calculatePort(options);
+    await this.setEnvVar(envFilePath, "PORT", String(port));
+    return port;
+  }
+  /**
+   * Validate environment configuration
+   */
+  async validateEnvFile(filePath) {
+    try {
+      const content = await fs.readFile(filePath, "utf8");
+      const envMap = parseEnvFile(content);
+      const errors = [];
+      for (const [key, value] of envMap.entries()) {
+        const validation = validateEnvVariable(key, value);
+        if (!validation.valid) {
+          errors.push(`${key}: ${validation.error}`);
+        }
+      }
+      return {
+        valid: errors.length === 0,
+        errors
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [
+          `Failed to read or parse file: ${error instanceof Error ? error.message : String(error)}`
+        ]
+      };
+    }
+  }
+  /**
+   * Create backup of existing file
+   */
+  async createBackup(filePath) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const backupPath = `${filePath}${this.backupSuffix}-${timestamp}`;
+    await fs.copy(filePath, backupPath);
+    logger2.debug(`Created backup at ${backupPath}`);
+    return backupPath;
+  }
+};
+
+// src/lib/CLIIsolationManager.ts
+import fs2 from "fs-extra";
+import path from "path";
+import os from "os";
+var CLIIsolationManager = class {
+  constructor() {
+    this.iloomBinDir = path.join(os.homedir(), ".iloom", "bin");
+  }
+  /**
+   * Setup CLI isolation for a worktree
+   * - Build the project
+   * - Create versioned symlinks
+   * - Check PATH configuration
+   * @param worktreePath Path to the worktree
+   * @param identifier Issue/PR number or branch identifier
+   * @param binEntries Bin entries from package.json
+   * @returns Array of created symlink names
+   */
+  async setupCLIIsolation(worktreePath, identifier, binEntries) {
+    await this.buildProject(worktreePath);
+    await this.verifyBinTargets(worktreePath, binEntries);
+    await fs2.ensureDir(this.iloomBinDir);
+    const symlinkNames = await this.createVersionedSymlinks(
+      worktreePath,
+      identifier,
+      binEntries
+    );
+    await this.ensureIloomBinInPath();
+    return symlinkNames;
+  }
+  /**
+   * Build the project using package.json build script
+   * @param worktreePath Path to the worktree
+   */
+  async buildProject(worktreePath) {
+    const pkgJson = await readPackageJson(worktreePath);
+    if (!hasScript(pkgJson, "build")) {
+      logger.warn("No build script found in package.json - skipping build");
+      return;
+    }
+    logger.info("Building CLI tool...");
+    await runScript("build", worktreePath);
+    logger.success("Build completed");
+  }
+  /**
+   * Verify bin targets exist and are executable
+   * @param worktreePath Path to the worktree
+   * @param binEntries Bin entries from package.json
+   */
+  async verifyBinTargets(worktreePath, binEntries) {
+    for (const binPath of Object.values(binEntries)) {
+      const targetPath = path.resolve(worktreePath, binPath);
+      const exists = await fs2.pathExists(targetPath);
+      if (!exists) {
+        throw new Error(`Bin target does not exist: ${targetPath}`);
+      }
+      try {
+        await fs2.access(targetPath, fs2.constants.X_OK);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Create versioned symlinks in ~/.iloom/bin
+   * @param worktreePath Path to the worktree
+   * @param identifier Issue/PR number or branch identifier
+   * @param binEntries Bin entries from package.json
+   * @returns Array of created symlink names
+   */
+  async createVersionedSymlinks(worktreePath, identifier, binEntries) {
+    const symlinkNames = [];
+    for (const [binName, binPath] of Object.entries(binEntries)) {
+      const versionedName = `${binName}-${identifier}`;
+      const targetPath = path.resolve(worktreePath, binPath);
+      const symlinkPath = path.join(this.iloomBinDir, versionedName);
+      await fs2.symlink(targetPath, symlinkPath);
+      logger.success(`CLI available: ${versionedName}`);
+      symlinkNames.push(versionedName);
+    }
+    return symlinkNames;
+  }
+  /**
+   * Check if ~/.iloom/bin is in PATH and provide setup instructions
+   */
+  async ensureIloomBinInPath() {
+    const currentPath = process.env.PATH ?? "";
+    if (currentPath.includes(".iloom/bin")) {
+      return;
+    }
+    const shell = this.detectShell();
+    const rcFile = this.getShellRcFile(shell);
+    logger.warn("\n\u26A0\uFE0F  One-time PATH setup required:");
+    logger.warn(`   Add to ${rcFile}:`);
+    logger.warn(`   export PATH="$HOME/.iloom/bin:$PATH"`);
+    logger.warn(`   Then run: source ${rcFile}
+`);
+  }
+  /**
+   * Detect current shell
+   * @returns Shell name (zsh, bash, fish, etc.)
+   */
+  detectShell() {
+    const shell = process.env.SHELL ?? "";
+    return shell.split("/").pop() ?? "bash";
+  }
+  /**
+   * Get RC file path for shell
+   * @param shell Shell name
+   * @returns RC file path
+   */
+  getShellRcFile(shell) {
+    const rcFiles = {
+      zsh: "~/.zshrc",
+      bash: "~/.bashrc",
+      fish: "~/.config/fish/config.fish"
+    };
+    return rcFiles[shell] ?? "~/.bashrc";
+  }
+  /**
+   * Cleanup versioned CLI executables for a specific identifier
+   * Removes all symlinks matching the pattern: {binName}-{identifier}
+   *
+   * @param identifier - Issue/PR number or branch identifier
+   * @returns Array of removed symlink names
+   */
+  async cleanupVersionedExecutables(identifier) {
+    const removed = [];
+    try {
+      const files = await fs2.readdir(this.iloomBinDir);
+      for (const file of files) {
+        if (this.matchesIdentifier(file, identifier)) {
+          const symlinkPath = path.join(this.iloomBinDir, file);
+          try {
+            await fs2.unlink(symlinkPath);
+            removed.push(file);
+          } catch (error) {
+            const isEnoent = error && typeof error === "object" && "code" in error && error.code === "ENOENT";
+            if (isEnoent) {
+              removed.push(file);
+              continue;
+            }
+            logger.warn(
+              `Failed to remove symlink ${file}: ${error instanceof Error ? error.message : "Unknown error"}`
+            );
+          }
+        }
+      }
+    } catch (error) {
+      const isEnoent = error && typeof error === "object" && "code" in error && error.code === "ENOENT";
+      if (isEnoent) {
+        logger.warn("No CLI executables directory found - nothing to cleanup");
+        return [];
+      }
+      throw error;
+    }
+    if (removed.length > 0) {
+      logger.success(`Removed CLI executables: ${removed.join(", ")}`);
+    }
+    return removed;
+  }
+  /**
+   * Find orphaned symlinks in ~/.iloom/bin
+   * Returns symlinks that point to non-existent targets
+   *
+   * @returns Array of orphaned symlink information
+   */
+  async findOrphanedSymlinks() {
+    const orphaned = [];
+    try {
+      const files = await fs2.readdir(this.iloomBinDir);
+      for (const file of files) {
+        const symlinkPath = path.join(this.iloomBinDir, file);
+        try {
+          const stats = await fs2.lstat(symlinkPath);
+          if (stats.isSymbolicLink()) {
+            const target = await fs2.readlink(symlinkPath);
+            try {
+              await fs2.access(target);
+            } catch {
+              orphaned.push({
+                name: file,
+                path: symlinkPath,
+                brokenTarget: target
+              });
+            }
+          }
+        } catch (error) {
+          logger.warn(
+            `Failed to check symlink ${file}: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      }
+    } catch (error) {
+      const isEnoent = error && typeof error === "object" && "code" in error && error.code === "ENOENT";
+      if (isEnoent) {
+        return [];
+      }
+      throw error;
+    }
+    return orphaned;
+  }
+  /**
+   * Cleanup all orphaned symlinks
+   * Removes symlinks that point to non-existent targets
+   *
+   * @returns Number of symlinks removed
+   */
+  async cleanupOrphanedSymlinks() {
+    const orphaned = await this.findOrphanedSymlinks();
+    let removedCount = 0;
+    for (const symlink of orphaned) {
+      try {
+        await fs2.unlink(symlink.path);
+        removedCount++;
+        logger.success(`Removed orphaned symlink: ${symlink.name}`);
+      } catch (error) {
+        logger.warn(
+          `Failed to remove orphaned symlink ${symlink.name}: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+    return removedCount;
+  }
+  /**
+   * Check if a filename matches the versioned pattern for an identifier
+   * Pattern: {binName}-{identifier}
+   *
+   * @param fileName - Name of the file to check
+   * @param identifier - Issue/PR number or branch identifier
+   * @returns True if the filename matches the pattern
+   */
+  matchesIdentifier(fileName, identifier) {
+    const suffix = `-${identifier}`;
+    return fileName.endsWith(suffix);
+  }
+};
+
+// src/lib/DatabaseManager.ts
+var logger3 = createLogger({ prefix: "\u{1F5C2}\uFE0F" });
+var DatabaseManager = class {
+  constructor(provider, environment, databaseUrlEnvVarName = "DATABASE_URL") {
+    this.provider = provider;
+    this.environment = environment;
+    this.databaseUrlEnvVarName = databaseUrlEnvVarName;
+    if (databaseUrlEnvVarName !== "DATABASE_URL") {
+      logger3.debug(`\u{1F527} DatabaseManager configured with custom variable: ${databaseUrlEnvVarName}`);
+    } else {
+      logger3.debug("\u{1F527} DatabaseManager using default variable: DATABASE_URL");
+    }
+  }
+  /**
+   * Get the configured database URL environment variable name
+   */
+  getConfiguredVariableName() {
+    return this.databaseUrlEnvVarName;
+  }
+  /**
+   * Check if database branching should be used
+   * Requires BOTH conditions:
+   *   1. Database provider is properly configured (checked via provider.isConfigured())
+   *   2. .env file contains the configured database URL variable
+   */
+  async shouldUseDatabaseBranching(envFilePath) {
+    if (!this.provider.isConfigured()) {
+      logger3.debug("Skipping database branching: Database provider not configured");
+      return false;
+    }
+    const hasDatabaseUrl = await this.hasDatabaseUrlInEnv(envFilePath);
+    if (!hasDatabaseUrl) {
+      logger3.debug(
+        "Skipping database branching: configured database URL variable not found in .env file"
+      );
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Create database branch only if configured
+   * Returns connection string if branch was created, null if skipped
+   *
+   * @param branchName - Name of the branch to create
+   * @param envFilePath - Path to .env file for configuration checks
+   * @param cwd - Optional working directory to run commands from
+   */
+  async createBranchIfConfigured(branchName, envFilePath, cwd) {
+    if (!await this.shouldUseDatabaseBranching(envFilePath)) {
+      return null;
+    }
+    if (!await this.provider.isCliAvailable()) {
+      logger3.warn("Skipping database branch creation: Neon CLI not available");
+      logger3.warn("Install with: npm install -g neonctl");
+      return null;
+    }
+    try {
+      const isAuth = await this.provider.isAuthenticated(cwd);
+      if (!isAuth) {
+        logger3.warn("Skipping database branch creation: Not authenticated with Neon CLI");
+        logger3.warn("Run: neon auth");
+        return null;
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger3.error(`Database authentication check failed: ${errorMessage}`);
+      throw error;
+    }
+    try {
+      const connectionString = await this.provider.createBranch(branchName, void 0, cwd);
+      logger3.success(`Database branch ready: ${this.provider.sanitizeBranchName(branchName)}`);
+      return connectionString;
+    } catch (error) {
+      logger3.error(
+        `Failed to create database branch: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  /**
+   * Delete database branch only if configured
+   * Returns result object indicating what happened
+   *
+   * @param branchName - Name of the branch to delete
+   * @param shouldCleanup - Boolean indicating if database cleanup should be performed (pre-fetched config)
+   * @param isPreview - Whether this is a preview database branch
+   * @param cwd - Optional working directory to run commands from (prevents issues with deleted directories)
+   */
+  async deleteBranchIfConfigured(branchName, shouldCleanup, isPreview = false, cwd) {
+    if (shouldCleanup === false) {
+      return {
+        success: true,
+        deleted: false,
+        notFound: true,
+        // Treat "not configured" as "nothing to delete"
+        branchName
+      };
+    }
+    if (!this.provider.isConfigured()) {
+      logger3.debug("Skipping database branch deletion: Database provider not configured");
+      return {
+        success: true,
+        deleted: false,
+        notFound: true,
+        branchName
+      };
+    }
+    if (!await this.provider.isCliAvailable()) {
+      logger3.info("Skipping database branch deletion: CLI tool not available");
+      return {
+        success: false,
+        deleted: false,
+        notFound: true,
+        error: "CLI tool not available",
+        branchName
+      };
+    }
+    try {
+      const isAuth = await this.provider.isAuthenticated(cwd);
+      if (!isAuth) {
+        logger3.warn("Skipping database branch deletion: Not authenticated with DB Provider");
+        return {
+          success: false,
+          deleted: false,
+          notFound: false,
+          error: "Not authenticated with DB Provider",
+          branchName
+        };
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger3.error(`Database authentication check failed: ${errorMessage}`);
+      return {
+        success: false,
+        deleted: false,
+        notFound: false,
+        error: `Authentication check failed: ${errorMessage}`,
+        branchName
+      };
+    }
+    try {
+      const result = await this.provider.deleteBranch(branchName, isPreview, cwd);
+      return result;
+    } catch (error) {
+      logger3.warn(
+        `Unexpected error in database deletion: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return {
+        success: false,
+        deleted: false,
+        notFound: false,
+        error: error instanceof Error ? error.message : String(error),
+        branchName
+      };
+    }
+  }
+  /**
+   * Check if .env has the configured database URL variable
+   * CRITICAL: If user explicitly configured a custom variable name (not default),
+   * throw an error if it's missing from .env
+   */
+  async hasDatabaseUrlInEnv(envFilePath) {
+    try {
+      const envMap = await this.environment.readEnvFile(envFilePath);
+      if (this.databaseUrlEnvVarName !== "DATABASE_URL") {
+        logger3.debug(`Looking for custom database URL variable: ${this.databaseUrlEnvVarName}`);
+      } else {
+        logger3.debug("Looking for default database URL variable: DATABASE_URL");
+      }
+      if (envMap.has(this.databaseUrlEnvVarName)) {
+        if (this.databaseUrlEnvVarName !== "DATABASE_URL") {
+          logger3.debug(`\u2705 Found custom database URL variable: ${this.databaseUrlEnvVarName}`);
+        } else {
+          logger3.debug(`\u2705 Found default database URL variable: DATABASE_URL`);
+        }
+        return true;
+      }
+      if (this.databaseUrlEnvVarName !== "DATABASE_URL") {
+        logger3.debug(`\u274C Custom database URL variable '${this.databaseUrlEnvVarName}' not found in .env file`);
+        throw new Error(
+          `Configured database URL environment variable '${this.databaseUrlEnvVarName}' not found in .env file. Please add it to your .env file or update your iloom configuration.`
+        );
+      }
+      const hasDefaultVar = envMap.has("DATABASE_URL");
+      if (hasDefaultVar) {
+        logger3.debug("\u2705 Found fallback DATABASE_URL variable");
+      } else {
+        logger3.debug("\u274C No DATABASE_URL variable found in .env file");
+      }
+      return hasDefaultVar;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not found in .env")) {
+        throw error;
+      }
+      return false;
+    }
+  }
+};
+
+export {
+  EnvironmentManager,
+  CLIIsolationManager,
+  DatabaseManager
+};
+//# sourceMappingURL=chunk-HPJJSYNS.js.map