@iloom/cli 0.10.0 → 0.10.1

package/dist/chunk-GRISNU6G.js

@@ -0,0 +1,651 @@
+#!/usr/bin/env node
+import {
+  CLIIsolationManager,
+  DatabaseManager,
+  EnvironmentManager,
+  LoomManager
+} from "./chunk-ZNMPGMHY.js";
+import {
+  buildDependencyMap,
+  fetchChildIssueDetails,
+  fetchChildIssues
+} from "./chunk-QZWEJVWV.js";
+import {
+  matchIssueIdentifier
+} from "./chunk-63QWFWH3.js";
+import {
+  createNeonProviderFromSettings
+} from "./chunk-P4O6EH46.js";
+import {
+  TelemetryService
+} from "./chunk-RSYT7MVI.js";
+import {
+  GitWorktreeManager
+} from "./chunk-I5T677EA.js";
+import {
+  FirstRunManager
+} from "./chunk-Q7POFB5Q.js";
+import {
+  capitalizeFirstLetter
+} from "./chunk-4E7LCFUG.js";
+import {
+  ProjectCapabilityDetector
+} from "./chunk-MORRVYPT.js";
+import {
+  getConfiguredRepoFromSettings,
+  hasMultipleRemotes
+} from "./chunk-FXDYIV3K.js";
+import {
+  ClaudeContextManager
+} from "./chunk-E6KOWMKA.js";
+import {
+  extractSettingsOverrides
+} from "./chunk-GYCR2LOU.js";
+import {
+  DefaultBranchNamingService
+} from "./chunk-QVLPWNE3.js";
+import {
+  findMainWorktreePathWithSettings,
+  getRepoRoot
+} from "./chunk-4FGEGQW4.js";
+import {
+  SettingsManager
+} from "./chunk-7VHJNVLF.js";
+import {
+  IssueTrackerFactory
+} from "./chunk-UKBAJ2QQ.js";
+import {
+  GitHubService
+} from "./chunk-KXDRI47U.js";
+import {
+  getLogger
+} from "./chunk-6MLEBAYZ.js";
+import {
+  isInteractiveEnvironment,
+  promptConfirmation,
+  waitForKeypress
+} from "./chunk-7JDMYTFZ.js";
+import {
+  loadEnvIntoProcess,
+  logger
+} from "./chunk-VT4PDUYT.js";
+
+// src/utils/first-run-setup.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import path from "path";
+import chalk from "chalk";
+async function getProjectRoot() {
+  const repoRoot = await getRepoRoot();
+  if (repoRoot) {
+    logger.debug(`getProjectRoot: Using git repo root: ${repoRoot}`);
+    return repoRoot;
+  }
+  const cwd = process.cwd();
+  logger.debug(`getProjectRoot: Not in git repo, using cwd: ${cwd}`);
+  return cwd;
+}
+async function needsFirstRunSetup() {
+  const projectRoot = await getProjectRoot();
+  const firstRunManager = new FirstRunManager();
+  const isConfigured = await firstRunManager.isProjectConfigured(projectRoot);
+  if (isConfigured) {
+    logger.debug("needsFirstRunSetup: Project is tracked as configured globally");
+    return false;
+  }
+  const iloomDir = path.join(projectRoot, ".iloom");
+  if (!existsSync(iloomDir)) {
+    return true;
+  }
+  const settingsPath = path.join(iloomDir, "settings.json");
+  const settingsLocalPath = path.join(iloomDir, "settings.local.json");
+  const hasSettings = await hasNonEmptySettings(settingsPath);
+  const hasLocalSettings = await hasNonEmptySettings(settingsLocalPath);
+  return !hasSettings && !hasLocalSettings;
+}
+async function hasNonEmptySettings(filePath) {
+  if (!existsSync(filePath)) return false;
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    return Object.keys(parsed).length > 0;
+  } catch {
+    return false;
+  }
+}
+function displayDefaultsBox() {
+  logger.info(chalk.bold("Default Configuration:"));
+  logger.info("");
+  logger.info(`  ${chalk.cyan("Main Branch:")}     main`);
+  logger.info(`  ${chalk.cyan("IDE:")}             vscode`);
+  logger.info(`  ${chalk.cyan("Issue Tracker:")}   GitHub Issues`);
+  logger.info(`  ${chalk.cyan("Merge Mode:")}      local ${chalk.dim("(merge locally)")}`);
+  logger.info(`  ${chalk.cyan("Base Port:")}       3000`);
+}
+async function launchFirstRunSetup() {
+  logger.info("First-time project setup detected.");
+  logger.info("");
+  displayDefaultsBox();
+  logger.info("");
+  const acceptDefaults = await promptConfirmation(
+    "Are these defaults OK?",
+    true
+    // default to true, so Enter accepts
+  );
+  if (acceptDefaults) {
+    const projectRoot = await getProjectRoot();
+    const firstRunManager = new FirstRunManager();
+    await firstRunManager.markProjectAsConfigured(projectRoot);
+    logger.info(chalk.green("Configuration complete! Using defaults."));
+    logger.info("You can run `il init` anytime to customize settings.");
+    return;
+  }
+  logger.info("");
+  logger.info("iloom will now launch an interactive configuration session with Claude.");
+  await waitForKeypress("Press any key to start configuration...");
+  const { InitCommand } = await import("./init-32YOKXRL.js");
+  const initCommand = new InitCommand();
+  await initCommand.execute(
+    "Help me configure iloom settings for this project. This is my first time using iloom here. Note: Your iloom command will execute once we are done with configuration changes."
+  );
+  logger.info("Configuration complete! Continuing with your original command...");
+}
+
+// src/commands/start.ts
+import path2 from "path";
+var StartCommand = class {
+  constructor(issueTracker, loomManager, _agentManager, settingsManager) {
+    this.loomManager = null;
+    this.githubService = null;
+    this.issueTracker = issueTracker;
+    this.settingsManager = settingsManager ?? new SettingsManager();
+    this.providedLoomManager = loomManager;
+    const envResult = loadEnvIntoProcess();
+    if (envResult.error) {
+      getLogger().debug(`Environment loading warning: ${envResult.error.message}`);
+    }
+    if (envResult.parsed) {
+      getLogger().debug(`Loaded ${Object.keys(envResult.parsed).length} environment variables`);
+    }
+  }
+  /**
+   * Get or create a GitHubService instance for PR operations
+   * Used when the configured issue tracker doesn't support PRs (e.g., Linear)
+   */
+  getGitHubService() {
+    this.githubService ??= new GitHubService();
+    return this.githubService;
+  }
+  /**
+   * Initialize LoomManager with the main worktree path
+   * Uses lazy initialization to ensure we have the correct path
+   */
+  async initializeLoomManager() {
+    var _a, _b;
+    if (this.loomManager) {
+      return this.loomManager;
+    }
+    if (this.providedLoomManager) {
+      this.loomManager = this.providedLoomManager;
+      return this.loomManager;
+    }
+    const mainWorktreePath = await findMainWorktreePathWithSettings();
+    const settings = await this.settingsManager.loadSettings();
+    const environmentManager = new EnvironmentManager();
+    const neonProvider = createNeonProviderFromSettings(settings);
+    const databaseUrlEnvVarName = ((_b = (_a = settings.capabilities) == null ? void 0 : _a.database) == null ? void 0 : _b.databaseUrlEnvVarName) ?? "DATABASE_URL";
+    const databaseManager = new DatabaseManager(neonProvider, environmentManager, databaseUrlEnvVarName);
+    const branchNaming = new DefaultBranchNamingService({ useClaude: true });
+    this.loomManager = new LoomManager(
+      new GitWorktreeManager(mainWorktreePath),
+      this.issueTracker,
+      branchNaming,
+      // Add branch naming service
+      environmentManager,
+      // Reuse same instance
+      new ClaudeContextManager(),
+      new ProjectCapabilityDetector(),
+      new CLIIsolationManager(),
+      this.settingsManager,
+      // Use same instance with CLI overrides
+      databaseManager
+      // Add database manager
+    );
+    return this.loomManager;
+  }
+  /**
+   * Main entry point for the start command
+   */
+  async execute(input) {
+    var _a, _b, _c, _d, _e;
+    const isJsonMode = input.options.json === true;
+    try {
+      const initialSettings = await this.settingsManager.loadSettings();
+      if (!isJsonMode && (process.env.FORCE_FIRST_TIME_SETUP === "true" || await needsFirstRunSetup())) {
+        await launchFirstRunSetup();
+        const newSettings = await this.settingsManager.loadSettings();
+        const newProvider = ((_a = newSettings.issueManagement) == null ? void 0 : _a.provider) ?? "github";
+        if (newProvider !== this.issueTracker.providerName) {
+          getLogger().debug(`Reinitializing issue tracker: provider changed to "${newProvider}"`);
+          this.issueTracker = IssueTrackerFactory.create(newSettings);
+        }
+      }
+      let repo;
+      if (this.issueTracker.providerName === "github" && await hasMultipleRemotes()) {
+        repo = await getConfiguredRepoFromSettings(initialSettings);
+        getLogger().info(`Using GitHub repository: ${repo}`);
+      }
+      const loomManager = await this.initializeLoomManager();
+      let parentLoom = await this.detectParentLoom(loomManager);
+      const parsed = await this.parseInput(input.identifier, repo);
+      await this.validateInput(parsed, repo);
+      if (parentLoom) {
+        const parentDisplay = parentLoom.type === "issue" ? `issue #${parentLoom.identifier}` : parentLoom.type === "pr" ? `PR #${parentLoom.identifier}` : `branch ${parentLoom.identifier}`;
+        if (input.options.childLoom === true) {
+          getLogger().info(`Creating as child loom of ${parentDisplay} (--child-loom flag)`);
+        } else if (input.options.childLoom === false) {
+          parentLoom = null;
+          getLogger().info("Creating as independent loom (--no-child-loom flag)");
+        } else {
+          if (isJsonMode) {
+            throw new Error("JSON mode requires explicit --child-loom or --no-child-loom flag when running from inside a loom");
+          }
+          let createAsChild = true;
+          if (isInteractiveEnvironment()) {
+            createAsChild = await promptConfirmation(
+              `You are not in your main worktree. Create as a child loom of ${parentDisplay}?`,
+              true
+              // Default yes
+            );
+          } else {
+            throw new Error("Non-interactive environment detected, use either --child-loom or --no-child-loom to specify behavior");
+          }
+          if (!createAsChild) {
+            parentLoom = null;
+            getLogger().info("Creating as independent loom");
+          }
+        }
+      } else if (input.options.childLoom === true) {
+        getLogger().debug("--child-loom flag provided but not running from inside an existing loom (ignored)");
+      }
+      if (parsed.type === "description") {
+        getLogger().info("Creating issue from description...");
+        const title = capitalizeFirstLetter(parsed.originalInput);
+        const body = input.options.body ? capitalizeFirstLetter(input.options.body) : "";
+        const result = await this.issueTracker.createIssue(
+          title,
+          // Use capitalized description as title
+          body
+          // Use capitalized body or empty
+        );
+        getLogger().success(`Created issue #${result.number}: ${result.url}`);
+        parsed.type = "issue";
+        parsed.number = result.number;
+      }
+      let childIssueNumbers = [];
+      let childIssues = [];
+      let dependencyMap = {};
+      if (parsed.type === "issue" && parsed.number) {
+        const settings2 = await this.settingsManager.loadSettings();
+        const epicIssueTracker = IssueTrackerFactory.create(settings2);
+        let children = [];
+        try {
+          children = await fetchChildIssues(String(parsed.number), epicIssueTracker, repo);
+        } catch (error) {
+          getLogger().warn(`Failed to check for child issues: ${error instanceof Error ? error.message : "Unknown error"}. Proceeding as normal loom.`);
+        }
+        if (children.length > 0) {
+          childIssueNumbers = children.map((c) => c.id);
+          let createAsEpic = false;
+          if (input.options.epic === true) {
+            createAsEpic = true;
+            getLogger().info(`Creating as epic loom with ${children.length} child issue(s) (--epic flag)`);
+          } else if (input.options.epic === false) {
+            createAsEpic = false;
+            getLogger().info("Creating as normal loom (--no-epic flag)");
+          } else {
+            if (isJsonMode) {
+              throw new Error("JSON mode requires explicit --epic or --no-epic flag when issue has child issues");
+            }
+            if (isInteractiveEnvironment()) {
+              createAsEpic = await promptConfirmation(
+                `This issue has ${children.length} child issue(s). Create as epic loom?`,
+                true
+                // Default yes
+              );
+            } else {
+              throw new Error("Non-interactive environment detected, use either --epic or --no-epic to specify behavior");
+            }
+          }
+          if (createAsEpic) {
+            parsed.type = "epic";
+            try {
+              const [details, depMap] = await Promise.all([
+                fetchChildIssueDetails(String(parsed.number), epicIssueTracker, repo),
+                buildDependencyMap(childIssueNumbers, settings2, repo)
+              ]);
+              childIssues = details ?? [];
+              dependencyMap = depMap ?? {};
+              getLogger().info(`Fetched ${childIssues.length} child issue details and dependency map`);
+            } catch (error) {
+              parsed.type = "issue";
+              childIssueNumbers = [];
+              getLogger().warn(`Failed to fetch epic child data, reverting to normal loom: ${error instanceof Error ? error.message : String(error)}`);
+            }
+          } else {
+            childIssueNumbers = [];
+          }
+        }
+      }
+      if (input.options.oneShot === "bypassPermissions" && input.options.claude !== false && !isJsonMode) {
+        const confirmed = await promptConfirmation(
+          "WARNING: bypassPermissions mode will allow Claude to execute all tool calls without confirmation. This can be dangerous. Do you want to proceed?"
+        );
+        if (!confirmed) {
+          getLogger().info("Operation cancelled by user");
+          process.exit(0);
+        }
+      }
+      const cliOverrides = extractSettingsOverrides();
+      const settings = await this.settingsManager.loadSettings(void 0, cliOverrides);
+      const workflowType = parsed.type === "branch" ? "regular" : parsed.type === "epic" ? "issue" : parsed.type;
+      const workflowConfig = (_b = settings.workflows) == null ? void 0 : _b[workflowType];
+      const { extractRawSetArguments, getExecutablePath } = await import("./cli-overrides-XFZWY7CM.js");
+      const setArguments = extractRawSetArguments();
+      const executablePath = getExecutablePath();
+      getLogger().info(`Validated input: ${this.formatParsedInput(parsed)}`);
+      const identifier = parsed.type === "branch" ? parsed.branchName ?? "" : parsed.number ?? 0;
+      const enableClaude = input.options.claude ?? (workflowConfig == null ? void 0 : workflowConfig.startAiAgent) ?? true;
+      const enableCode = input.options.code ?? (workflowConfig == null ? void 0 : workflowConfig.startIde) ?? true;
+      const enableDevServer = input.options.devServer ?? (workflowConfig == null ? void 0 : workflowConfig.startDevServer) ?? true;
+      const enableTerminal = input.options.terminal ?? (workflowConfig == null ? void 0 : workflowConfig.startTerminal) ?? false;
+      getLogger().debug("Final workflow config values:", {
+        enableClaude,
+        enableCode,
+        enableDevServer,
+        enableTerminal
+      });
+      const loom = await loomManager.createIloom({
+        type: parsed.type,
+        identifier,
+        originalInput: parsed.originalInput,
+        ...parentLoom && { parentLoom },
+        options: {
+          enableClaude,
+          enableCode,
+          enableDevServer,
+          enableTerminal,
+          ...input.options.oneShot && { oneShot: input.options.oneShot },
+          ...setArguments.length > 0 && { setArguments },
+          ...executablePath && { executablePath },
+          ...childIssueNumbers.length > 0 && { childIssueNumbers },
+          ...childIssues.length > 0 && { childIssues },
+          ...Object.keys(dependencyMap).length > 0 && { dependencyMap }
+        }
+      });
+      getLogger().success(`Created loom: ${loom.id} at ${loom.path}`);
+      try {
+        const oneShotMap = {
+          noReview: "skip-reviews",
+          bypassPermissions: "yolo"
+        };
+        TelemetryService.getInstance().track("loom.created", {
+          source_type: parsed.type === "epic" ? "issue" : parsed.type,
+          tracker: this.issueTracker.providerName,
+          is_child_loom: !!parentLoom,
+          one_shot_mode: oneShotMap[input.options.oneShot ?? ""] ?? "default"
+        });
+      } catch (error) {
+        getLogger().debug(`Failed to track loom.created telemetry: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      getLogger().info(`   Branch: ${loom.branch}`);
+      if ((_c = loom.capabilities) == null ? void 0 : _c.includes("web")) {
+        getLogger().info(`   Port: ${loom.port}`);
+      }
+      if ((_d = loom.issueData) == null ? void 0 : _d.title) {
+        getLogger().info(`   Title: ${loom.issueData.title}`);
+      }
+      if (parsed.type === "epic") {
+        getLogger().info(`   Epic: yes (${childIssueNumbers.length} child issue(s))`);
+      }
+      if (isJsonMode) {
+        return {
+          id: loom.id,
+          path: loom.path,
+          branch: loom.branch,
+          type: parsed.type,
+          identifier: loom.identifier,
+          ...loom.port !== void 0 && { port: loom.port },
+          ...((_e = loom.issueData) == null ? void 0 : _e.title) && { title: loom.issueData.title },
+          ...loom.capabilities && { capabilities: loom.capabilities },
+          ...childIssueNumbers.length > 0 && { childIssueNumbers }
+        };
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        getLogger().error(`${error.message}`);
+      } else {
+        getLogger().error("An unknown error occurred");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Parse input to determine type and extract relevant data
+   */
+  async parseInput(identifier, repo) {
+    const hasLeadingSpace = identifier.startsWith(" ");
+    const trimmedIdentifier = identifier.trim();
+    if (!trimmedIdentifier) {
+      throw new Error("Missing required argument: identifier");
+    }
+    const spaceCount = (trimmedIdentifier.match(/ /g) ?? []).length;
+    if (trimmedIdentifier.length > 15 && spaceCount >= 1) {
+      return {
+        type: "description",
+        originalInput: hasLeadingSpace ? " " + trimmedIdentifier : trimmedIdentifier
+      };
+    }
+    const prPattern = /^pr[/-](\d+)$/i;
+    const prMatch = trimmedIdentifier.match(prPattern);
+    if (prMatch == null ? void 0 : prMatch[1]) {
+      return {
+        type: "pr",
+        number: parseInt(prMatch[1], 10),
+        originalInput: trimmedIdentifier
+      };
+    }
+    const identifierMatch = matchIssueIdentifier(trimmedIdentifier);
+    if (identifierMatch.type === "project-key" && identifierMatch.identifier) {
+      const detection = await this.issueTracker.detectInputType(
+        trimmedIdentifier,
+        repo
+      );
+      if (detection.type === "issue" && detection.identifier) {
+        return {
+          type: "issue",
+          number: detection.identifier,
+          // Keep as string for project key identifiers
+          originalInput: trimmedIdentifier
+        };
+      }
+      throw new Error(
+        `Could not find issue matching identifier ${identifierMatch.identifier}`
+      );
+    }
+    if (identifierMatch.type === "numeric" && identifierMatch.identifier) {
+      const number = parseInt(identifierMatch.identifier, 10);
+      if (this.issueTracker.supportsPullRequests) {
+        const detection = await this.issueTracker.detectInputType(
+          trimmedIdentifier,
+          repo
+        );
+        if (detection.type === "pr") {
+          return {
+            type: "pr",
+            number: detection.identifier ? parseInt(detection.identifier, 10) : number,
+            originalInput: trimmedIdentifier
+          };
+        } else if (detection.type === "issue") {
+          return {
+            type: "issue",
+            number: detection.identifier ? parseInt(detection.identifier, 10) : number,
+            originalInput: trimmedIdentifier
+          };
+        } else {
+          throw new Error(`Could not find issue or PR #${number}`);
+        }
+      } else {
+        const githubService = this.getGitHubService();
+        const detection = await githubService.detectInputType(trimmedIdentifier, repo);
+        if (detection.type === "pr") {
+          return {
+            type: "pr",
+            number: detection.identifier ? parseInt(detection.identifier, 10) : number,
+            originalInput: trimmedIdentifier
+          };
+        } else {
+          return {
+            type: "issue",
+            number,
+            originalInput: trimmedIdentifier
+          };
+        }
+      }
+    }
+    return {
+      type: "branch",
+      branchName: trimmedIdentifier,
+      originalInput: trimmedIdentifier
+    };
+  }
+  /**
+   * Validate the parsed input based on its type
+   */
+  async validateInput(parsed, repo) {
+    switch (parsed.type) {
+      case "pr": {
+        if (!parsed.number) {
+          throw new Error("Invalid PR number");
+        }
+        if (this.issueTracker.supportsPullRequests && this.issueTracker.fetchPR && this.issueTracker.validatePRState) {
+          const pr = await this.issueTracker.fetchPR(parsed.number, repo);
+          await this.issueTracker.validatePRState(pr);
+        } else {
+          const githubService = this.getGitHubService();
+          const pr = await githubService.fetchPR(parsed.number, repo);
+          await githubService.validatePRState(pr);
+        }
+        getLogger().debug(`Validated PR #${parsed.number}`);
+        break;
+      }
+      case "issue": {
+        if (!parsed.number) {
+          throw new Error("Invalid issue number");
+        }
+        const issue = await this.issueTracker.fetchIssue(parsed.number, repo);
+        await this.issueTracker.validateIssueState(issue);
+        getLogger().debug(`Validated issue #${parsed.number}`);
+        break;
+      }
+      case "branch": {
+        if (!parsed.branchName) {
+          throw new Error("Invalid branch name");
+        }
+        if (!this.isValidBranchName(parsed.branchName)) {
+          throw new Error(
+            "Invalid branch name. Use only letters, numbers, hyphens, underscores, and slashes"
+          );
+        }
+        getLogger().debug(`Validated branch name: ${parsed.branchName}`);
+        break;
+      }
+      case "description": {
+        getLogger().debug("Detected description input", {
+          length: parsed.originalInput.length
+        });
+        break;
+      }
+      default: {
+        const unknownType = parsed;
+        throw new Error(`Unknown input type: ${unknownType.type}`);
+      }
+    }
+  }
+  /**
+   * Validate branch name format
+   */
+  isValidBranchName(branch) {
+    return /^[a-zA-Z0-9/_-]+$/.test(branch);
+  }
+  /**
+   * Format parsed input for display
+   */
+  formatParsedInput(parsed) {
+    switch (parsed.type) {
+      case "pr":
+        return `PR #${parsed.number}`;
+      case "issue":
+        return `Issue #${parsed.number}`;
+      case "epic":
+        return `Epic #${parsed.number}`;
+      case "branch":
+        return `Branch '${parsed.branchName}'`;
+      case "description":
+        return `Description: ${parsed.originalInput.slice(0, 50)}...`;
+      default:
+        return "Unknown input";
+    }
+  }
+  /**
+   * Detect if running from inside an existing loom worktree
+   * Returns parent loom info if detected, null otherwise
+   */
+  async detectParentLoom(loomManager) {
+    try {
+      const cwd = process.cwd();
+      const looms = await loomManager.listLooms();
+      if (!looms) {
+        return null;
+      }
+      const mainWorktreePath = await findMainWorktreePathWithSettings();
+      const parentLoom = looms.find((loom) => {
+        if (loom.path === mainWorktreePath) {
+          return false;
+        }
+        return cwd === loom.path || cwd.startsWith(loom.path + path2.sep);
+      });
+      if (!parentLoom) {
+        return null;
+      }
+      getLogger().debug(`Detected parent loom: ${parentLoom.type} ${parentLoom.identifier} at ${parentLoom.path}`);
+      const result = {
+        type: parentLoom.type,
+        identifier: parentLoom.identifier,
+        branchName: parentLoom.branch,
+        worktreePath: parentLoom.path
+      };
+      if (parentLoom.databaseBranch) {
+        result.databaseBranch = parentLoom.databaseBranch;
+      }
+      if (!result.databaseBranch) {
+        const databaseBranch = await loomManager.getDatabaseBranchForLoom(parentLoom.path);
+        if (databaseBranch) {
+          result.databaseBranch = databaseBranch;
+          getLogger().debug(`Detected parent database branch: ${databaseBranch}`);
+        }
+      }
+      return result;
+    } catch (error) {
+      getLogger().debug(`Failed to detect parent loom: ${error instanceof Error ? error.message : "Unknown error"}`);
+      return null;
+    }
+  }
+};
+
+export {
+  needsFirstRunSetup,
+  launchFirstRunSetup,
+  StartCommand
+};
+//# sourceMappingURL=chunk-GRISNU6G.js.map