@iloom/cli 0.5.1 → 0.5.3

package/dist/chunk-VT4PDUYT.js

@@ -0,0 +1,578 @@
+#!/usr/bin/env node
+
+// src/utils/env.ts
+import path from "path";
+import dotenvFlow from "dotenv-flow";
+
+// src/utils/logger.ts
+import chalk, { Chalk } from "chalk";
+
+// src/utils/terminal.ts
+import { execa } from "execa";
+import { existsSync } from "fs";
+function detectPlatform() {
+  const platform = process.platform;
+  if (platform === "darwin") return "darwin";
+  if (platform === "linux") return "linux";
+  if (platform === "win32") return "win32";
+  return "unsupported";
+}
+async function detectDarkMode() {
+  const platform = detectPlatform();
+  if (platform !== "darwin") {
+    return "light";
+  }
+  try {
+    const result = await execa("defaults", ["read", "-g", "AppleInterfaceStyle"]);
+    return result.stdout.trim().toLowerCase() === "dark" ? "dark" : "light";
+  } catch {
+    return "light";
+  }
+}
+async function detectITerm2() {
+  const platform = detectPlatform();
+  if (platform !== "darwin") return false;
+  return existsSync("/Applications/iTerm.app");
+}
+async function openTerminalWindow(options) {
+  const platform = detectPlatform();
+  if (platform !== "darwin") {
+    throw new Error(
+      `Terminal window launching not yet supported on ${platform}. Currently only macOS is supported.`
+    );
+  }
+  const hasITerm2 = await detectITerm2();
+  const applescript = hasITerm2 ? await buildITerm2SingleTabScript(options) : await buildAppleScript(options);
+  try {
+    await execa("osascript", ["-e", applescript]);
+    if (!hasITerm2) {
+      await execa("osascript", ["-e", 'tell application "Terminal" to activate']);
+    }
+  } catch (error) {
+    throw new Error(
+      `Failed to open terminal window: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+async function buildAppleScript(options) {
+  const {
+    workspacePath,
+    command,
+    backgroundColor,
+    port,
+    includeEnvSetup,
+    includePortExport
+  } = options;
+  const commands = [];
+  if (workspacePath) {
+    commands.push(`cd '${escapePathForAppleScript(workspacePath)}'`);
+  }
+  if (includeEnvSetup && workspacePath) {
+    const sourceCommands = await buildEnvSourceCommands(
+      workspacePath,
+      async (p) => existsSync(p)
+    );
+    commands.push(...sourceCommands);
+  }
+  if (includePortExport && port !== void 0) {
+    commands.push(`export PORT=${port}`);
+  }
+  if (command) {
+    commands.push(command);
+  }
+  const fullCommand = commands.join(" && ");
+  const historyFreeCommand = ` ${fullCommand}`;
+  let script = `tell application "Terminal"
+`;
+  script += `  set newTab to do script "${escapeForAppleScript(historyFreeCommand)}"
+`;
+  if (backgroundColor) {
+    const { r, g, b } = backgroundColor;
+    script += `  set background color of newTab to {${Math.round(r * 257)}, ${Math.round(g * 257)}, ${Math.round(b * 257)}}
+`;
+  }
+  script += `end tell`;
+  return script;
+}
+function escapePathForAppleScript(path2) {
+  return path2.replace(/'/g, "'\\''");
+}
+function escapeForAppleScript(command) {
+  return command.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+async function buildITerm2SingleTabScript(options) {
+  const command = await buildCommandSequence(options);
+  let script = 'tell application id "com.googlecode.iterm2"\n';
+  script += "  create window with default profile\n";
+  script += "  set s1 to current session of current window\n\n";
+  if (options.backgroundColor) {
+    const { r, g, b } = options.backgroundColor;
+    script += `  set background color of s1 to {${Math.round(r * 257)}, ${Math.round(g * 257)}, ${Math.round(b * 257)}}
+`;
+  }
+  script += `  tell s1 to write text "${escapeForAppleScript(command)}"
+
+`;
+  if (options.title) {
+    script += `  set name of s1 to "${escapeForAppleScript(options.title)}"
+
+`;
+  }
+  script += "  activate\n";
+  script += "end tell";
+  return script;
+}
+async function buildCommandSequence(options) {
+  const {
+    workspacePath,
+    command,
+    port,
+    includeEnvSetup,
+    includePortExport
+  } = options;
+  const commands = [];
+  if (workspacePath) {
+    commands.push(`cd '${escapePathForAppleScript(workspacePath)}'`);
+  }
+  if (includeEnvSetup && workspacePath) {
+    const sourceCommands = await buildEnvSourceCommands(
+      workspacePath,
+      async (p) => existsSync(p)
+    );
+    commands.push(...sourceCommands);
+  }
+  if (includePortExport && port !== void 0) {
+    commands.push(`export PORT=${port}`);
+  }
+  if (command) {
+    commands.push(command);
+  }
+  const fullCommand = commands.join(" && ");
+  return ` ${fullCommand}`;
+}
+async function buildITerm2MultiTabScript(optionsArray) {
+  if (optionsArray.length < 2) {
+    throw new Error("buildITerm2MultiTabScript requires at least 2 terminal options");
+  }
+  let script = 'tell application id "com.googlecode.iterm2"\n';
+  script += "  create window with default profile\n";
+  script += "  set newWindow to current window\n";
+  const options1 = optionsArray[0];
+  if (!options1) {
+    throw new Error("First terminal option is undefined");
+  }
+  const command1 = await buildCommandSequence(options1);
+  script += "  set s1 to current session of newWindow\n\n";
+  if (options1.backgroundColor) {
+    const { r, g, b } = options1.backgroundColor;
+    script += `  set background color of s1 to {${Math.round(r * 257)}, ${Math.round(g * 257)}, ${Math.round(b * 257)}}
+`;
+  }
+  script += `  tell s1 to write text "${escapeForAppleScript(command1)}"
+
+`;
+  if (options1.title) {
+    script += `  set name of s1 to "${escapeForAppleScript(options1.title)}"
+
+`;
+  }
+  for (let i = 1; i < optionsArray.length; i++) {
+    const options = optionsArray[i];
+    if (!options) {
+      throw new Error(`Terminal option at index ${i} is undefined`);
+    }
+    const command = await buildCommandSequence(options);
+    const sessionVar = `s${i + 1}`;
+    script += "  tell newWindow\n";
+    script += `    set newTab${i} to (create tab with default profile)
+`;
+    script += "  end tell\n";
+    script += `  set ${sessionVar} to current session of newTab${i}
+
+`;
+    if (options.backgroundColor) {
+      const { r, g, b } = options.backgroundColor;
+      script += `  set background color of ${sessionVar} to {${Math.round(r * 257)}, ${Math.round(g * 257)}, ${Math.round(b * 257)}}
+`;
+    }
+    script += `  tell ${sessionVar} to write text "${escapeForAppleScript(command)}"
+
+`;
+    if (options.title) {
+      script += `  set name of ${sessionVar} to "${escapeForAppleScript(options.title)}"
+
+`;
+    }
+  }
+  script += "  activate\n";
+  script += "end tell";
+  return script;
+}
+async function openMultipleTerminalWindows(optionsArray) {
+  if (optionsArray.length < 2) {
+    throw new Error("openMultipleTerminalWindows requires at least 2 terminal options. Use openTerminalWindow for single terminal.");
+  }
+  const platform = detectPlatform();
+  if (platform !== "darwin") {
+    throw new Error(
+      `Terminal window launching not yet supported on ${platform}. Currently only macOS is supported.`
+    );
+  }
+  const hasITerm2 = await detectITerm2();
+  if (hasITerm2) {
+    const applescript = await buildITerm2MultiTabScript(optionsArray);
+    try {
+      await execa("osascript", ["-e", applescript]);
+    } catch (error) {
+      throw new Error(
+        `Failed to open iTerm2 window: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  } else {
+    for (let i = 0; i < optionsArray.length; i++) {
+      const options = optionsArray[i];
+      if (!options) {
+        throw new Error(`Terminal option at index ${i} is undefined`);
+      }
+      await openTerminalWindow(options);
+      if (i < optionsArray.length - 1) {
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+      }
+    }
+  }
+}
+
+// src/utils/logger.ts
+var stdoutChalk = new Chalk({ level: chalk.level });
+var stderrChalk = new Chalk({ level: chalk.level });
+var currentThemeMode = "light";
+async function initializeThemeMode() {
+  try {
+    currentThemeMode = await detectDarkMode();
+  } catch {
+    currentThemeMode = "light";
+  }
+}
+void initializeThemeMode();
+function getInfoColor(chalkInstance) {
+  return currentThemeMode === "dark" ? chalkInstance.cyan : chalkInstance.blue;
+}
+function getSuccessColor(chalkInstance) {
+  return currentThemeMode === "dark" ? chalkInstance.greenBright : chalkInstance.green;
+}
+function getWarnColor(chalkInstance) {
+  return currentThemeMode === "dark" ? chalkInstance.yellowBright : chalkInstance.yellow;
+}
+function getErrorColor(chalkInstance) {
+  return currentThemeMode === "dark" ? chalkInstance.redBright : chalkInstance.red;
+}
+function getDebugColor(chalkInstance) {
+  return currentThemeMode === "dark" ? chalkInstance.gray : chalkInstance.gray;
+}
+function formatMessage(message, ...args) {
+  const formattedArgs = args.map(
+    (arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)
+  );
+  return formattedArgs.length > 0 ? `${message} ${formattedArgs.join(" ")}` : message;
+}
+function formatWithEmoji(message, emoji, colorFn) {
+  if (message.trim()) {
+    return colorFn(`${emoji} ${message}`);
+  } else {
+    return "";
+  }
+}
+var globalDebugEnabled = false;
+var logger = {
+  info: (message, ...args) => {
+    const formatted = formatMessage(message, ...args);
+    const output = formatWithEmoji(formatted, "\u{1F5C2}\uFE0F ", getInfoColor(stdoutChalk));
+    console.log(output);
+  },
+  success: (message, ...args) => {
+    const formatted = formatMessage(message, ...args);
+    const output = formatWithEmoji(formatted, "\u2705", getSuccessColor(stdoutChalk));
+    console.log(output);
+  },
+  warn: (message, ...args) => {
+    const formatted = formatMessage(message, ...args);
+    const output = formatWithEmoji(formatted, "\u26A0\uFE0F ", getWarnColor(stderrChalk));
+    console.error(output);
+  },
+  error: (message, ...args) => {
+    const formatted = formatMessage(message, ...args);
+    const output = formatWithEmoji(formatted, "\u274C", getErrorColor(stderrChalk));
+    console.error(output);
+  },
+  debug: (message, ...args) => {
+    if (globalDebugEnabled) {
+      const formatted = formatMessage(message, ...args);
+      const output = formatWithEmoji(formatted, "\u{1F50D}", getDebugColor(stdoutChalk));
+      console.log(output);
+    }
+  },
+  setDebug: (enabled) => {
+    globalDebugEnabled = enabled;
+  },
+  isDebugEnabled: () => {
+    return globalDebugEnabled;
+  },
+  stdout: process.stdout
+};
+function createStderrLogger(options = {}) {
+  const { prefix = "", timestamp = false, forceColor, debug = globalDebugEnabled } = options;
+  let localDebugEnabled = debug;
+  const customChalk = forceColor !== void 0 ? new Chalk({ level: forceColor ? 3 : 0 }) : stderrChalk;
+  const prefixStr = prefix ? `[${prefix}] ` : "";
+  const getTimestamp = () => timestamp ? `[${(/* @__PURE__ */ new Date()).toISOString()}] ` : "";
+  return {
+    info: (message, ...args) => {
+      const formatted = formatMessage(message, ...args);
+      const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
+      const output = formatWithEmoji(fullMessage, "\u{1F5C2}\uFE0F ", getInfoColor(customChalk));
+      console.error(output);
+    },
+    success: (message, ...args) => {
+      const formatted = formatMessage(message, ...args);
+      const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
+      const output = formatWithEmoji(fullMessage, "\u2705", getSuccessColor(customChalk));
+      console.error(output);
+    },
+    warn: (message, ...args) => {
+      const formatted = formatMessage(message, ...args);
+      const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
+      const output = formatWithEmoji(fullMessage, "\u26A0\uFE0F ", getWarnColor(customChalk));
+      console.error(output);
+    },
+    error: (message, ...args) => {
+      const formatted = formatMessage(message, ...args);
+      const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
+      const output = formatWithEmoji(fullMessage, "\u274C", getErrorColor(customChalk));
+      console.error(output);
+    },
+    debug: (message, ...args) => {
+      if (localDebugEnabled) {
+        const formatted = formatMessage(message, ...args);
+        const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
+        const output = formatWithEmoji(fullMessage, "\u{1F50D}", getDebugColor(customChalk));
+        console.error(output);
+      }
+    },
+    setDebug: (enabled) => {
+      localDebugEnabled = enabled;
+    },
+    isDebugEnabled: () => {
+      return globalDebugEnabled;
+    },
+    stdout: process.stderr
+    // Use stderr for progress output in JSON mode
+  };
+}
+var logger_default = logger;
+
+// src/utils/env.ts
+function parseEnvFile(content) {
+  const envMap = /* @__PURE__ */ new Map();
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine || trimmedLine.startsWith("#")) {
+      continue;
+    }
+    const cleanLine = trimmedLine.startsWith("export ") ? trimmedLine.substring(7) : trimmedLine;
+    const equalsIndex = cleanLine.indexOf("=");
+    if (equalsIndex === -1) {
+      continue;
+    }
+    const key = cleanLine.substring(0, equalsIndex).trim();
+    let value = cleanLine.substring(equalsIndex + 1);
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.substring(1, value.length - 1);
+      value = value.replace(/\\"/g, '"').replace(/\\'/g, "'");
+      value = value.replace(/\\n/g, "\n");
+    }
+    if (key) {
+      envMap.set(key, value);
+    }
+  }
+  return envMap;
+}
+function formatEnvLine(key, value) {
+  const escapedValue = value.replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+  return `${key}="${escapedValue}"`;
+}
+function validateEnvVariable(key, _value) {
+  if (!key || key.length === 0) {
+    return {
+      valid: false,
+      error: "Environment variable key cannot be empty"
+    };
+  }
+  if (!isValidEnvKey(key)) {
+    return {
+      valid: false,
+      error: `Invalid environment variable name: ${key}. Must start with a letter or underscore and contain only letters, numbers, and underscores.`
+    };
+  }
+  return { valid: true };
+}
+function extractPort(envContent) {
+  const portValue = envContent.get("PORT");
+  if (!portValue) {
+    return null;
+  }
+  const port = parseInt(portValue, 10);
+  if (isNaN(port)) {
+    return null;
+  }
+  return port;
+}
+function isValidEnvKey(key) {
+  if (!key || key.length === 0) {
+    return false;
+  }
+  const validKeyRegex = /^[A-Za-z_][A-Za-z0-9_]*$/;
+  return validKeyRegex.test(key);
+}
+function loadEnvIntoProcess(options) {
+  logger.debug("Loading environment variables with dotenv-flow", {
+    options: {
+      path: (options == null ? void 0 : options.path) ?? "current working directory",
+      nodeEnv: (options == null ? void 0 : options.nodeEnv) ?? "not specified",
+      defaultNodeEnv: (options == null ? void 0 : options.defaultNodeEnv) ?? "development (default)"
+    }
+  });
+  const configOptions = {
+    silent: true
+    // Don't throw errors if .env files are missing
+  };
+  if ((options == null ? void 0 : options.path) !== void 0) {
+    configOptions.path = options.path;
+    logger.debug(`Using custom path: ${options.path}`);
+  }
+  if ((options == null ? void 0 : options.nodeEnv) !== void 0) {
+    configOptions.node_env = options.nodeEnv;
+    logger.debug(`Using NODE_ENV: ${options.nodeEnv}`);
+  }
+  if ((options == null ? void 0 : options.defaultNodeEnv) !== void 0) {
+    configOptions.default_node_env = options.defaultNodeEnv;
+    logger.debug(`Using default NODE_ENV: ${options.defaultNodeEnv}`);
+  } else {
+    configOptions.default_node_env = "development";
+    logger.debug("Using default NODE_ENV: development");
+  }
+  logger.debug("dotenv-flow config options:", configOptions);
+  const result = dotenvFlow.config(configOptions);
+  const returnValue = {};
+  if (result.parsed) {
+    returnValue.parsed = result.parsed;
+    const variableCount = Object.keys(result.parsed).length;
+    logger.debug(`Successfully loaded ${variableCount} environment variables`);
+  } else {
+    logger.debug("No environment variables were parsed");
+  }
+  if (result.error) {
+    returnValue.error = result.error;
+    logger.debug("dotenv-flow returned an error", {
+      error: result.error.message,
+      name: result.error.name
+    });
+  } else {
+    logger.debug("dotenv-flow completed without errors");
+  }
+  return returnValue;
+}
+function isNoEnvFilesFoundError(error) {
+  return error.message.startsWith('no ".env*" files matching pattern');
+}
+function loadWorkspaceEnv(workspacePath) {
+  const nodeEnv = process.env.NODE_ENV ?? "development";
+  logger.debug("Loading workspace environment variables", {
+    workspacePath,
+    detectedNodeEnv: nodeEnv,
+    processNodeEnv: process.env.NODE_ENV ?? "not set"
+  });
+  return loadEnvIntoProcess({
+    path: workspacePath,
+    nodeEnv,
+    defaultNodeEnv: "development"
+  });
+}
+var DOTENV_FLOW_NODE_ENV = process.env.DOTENV_FLOW_NODE_ENV ?? "development";
+function getDotenvFlowFiles() {
+  return [
+    ".env",
+    ".env.local",
+    `.env.${DOTENV_FLOW_NODE_ENV}`,
+    `.env.${DOTENV_FLOW_NODE_ENV}.local`
+  ];
+}
+function getLocalEquivalent(filename) {
+  if (filename.endsWith(".local")) {
+    return filename;
+  }
+  return `${filename}.local`;
+}
+async function findEnvFileForDatabaseUrl(workspacePath, variableName, isFileTracked, fileExists, getEnvVariable) {
+  const file = await findEnvFileContainingVariable(workspacePath, variableName, fileExists, getEnvVariable);
+  if (file === null) {
+    return ".env.local";
+  }
+  const isTracked = await isFileTracked(file, workspacePath);
+  if (isTracked) {
+    return getLocalEquivalent(file);
+  }
+  return file;
+}
+async function buildEnvSourceCommands(workspacePath, fileExists) {
+  const files = getDotenvFlowFiles();
+  const commands = [];
+  for (const file of files) {
+    const fullPath = path.join(workspacePath, file);
+    const exists = await fileExists(fullPath);
+    if (exists) {
+      commands.push(`source ${file}`);
+    }
+  }
+  return commands;
+}
+async function findEnvFileContainingVariable(workspacePath, variableName, fileExists, getEnvVariable) {
+  const files = getDotenvFlowFiles().reverse();
+  for (const file of files) {
+    const fullPath = path.join(workspacePath, file);
+    if (!await fileExists(fullPath)) {
+      continue;
+    }
+    const value = await getEnvVariable(fullPath, variableName);
+    if (value !== null) {
+      return file;
+    }
+  }
+  return null;
+}
+async function hasVariableInAnyEnvFile(workspacePath, variableName, fileExists, getEnvVariable) {
+  const file = await findEnvFileContainingVariable(workspacePath, variableName, fileExists, getEnvVariable);
+  return file !== null;
+}
+
+export {
+  parseEnvFile,
+  formatEnvLine,
+  validateEnvVariable,
+  extractPort,
+  loadEnvIntoProcess,
+  isNoEnvFilesFoundError,
+  loadWorkspaceEnv,
+  getDotenvFlowFiles,
+  findEnvFileForDatabaseUrl,
+  findEnvFileContainingVariable,
+  hasVariableInAnyEnvFile,
+  detectDarkMode,
+  detectITerm2,
+  openTerminalWindow,
+  openMultipleTerminalWindows,
+  logger,
+  createStderrLogger,
+  logger_default
+};
+//# sourceMappingURL=chunk-VT4PDUYT.js.map