astro 6.0.0-alpha.0 → 6.0.0-alpha.1

package/dist/cli/add/index.js

@@ -6,7 +6,7 @@ import { diffWords } from "diff";
 import { builders, generateCode, loadFile } from "magicast";
 import { getDefaultExportOptions } from "magicast/helpers";
 import { detect, resolveCommand } from "package-manager-detector";
-import colors from "picocolors";
+import colors from "piccolore";
 import prompts from "prompts";
 import maxSatisfying from "semver/ranges/max-satisfying.js";
 import yoctoSpinner from "yocto-spinner";
@@ -134,7 +134,7 @@ async function add(names, { flags }) {
   const cwd = inlineConfig.root;
   const logger = createLoggerFromFlags(flags);
   const integrationNames = names.map((name) => ALIASES.has(name) ? ALIASES.get(name) : name);
-  const integrations = await validateIntegrations(integrationNames, flags);
+  const integrations = await validateIntegrations(integrationNames, flags, logger);
   let installResult = await tryToInstallIntegrations({ integrations, cwd, flags, logger });
   const rootPath = resolveRoot(cwd);
   const root = pathToFileURL(rootPath);
@@ -182,7 +182,7 @@ async function add(names, { flags }) {
   ${magenta(`Astro will scaffold ${green("./wrangler.jsonc")}.`)}
 `
           );
-          if (await askToContinue({ flags })) {
+          if (await askToContinue({ flags, logger })) {
             const data = await getPackageJson();
             await fs.writeFile(
               wranglerConfigURL,
@@ -202,7 +202,7 @@ async function add(names, { flags }) {
   ${magenta(`Astro will scaffold ${green("./public/.assetsignore")}.`)}
 `
           );
-          if (await askToContinue({ flags })) {
+          if (await askToContinue({ flags, logger })) {
             if (!existsSync(dir)) {
               await fs.mkdir(dir);
             }
@@ -222,7 +222,7 @@ async function add(names, { flags }) {
   ${magenta(`Astro will scaffold ${green("./src/styles/global.css")}.`)}
 `
           );
-          if (await askToContinue({ flags })) {
+          if (await askToContinue({ flags, logger })) {
             if (!existsSync(dir)) {
               await fs.mkdir(dir);
             }
@@ -261,7 +261,7 @@ async function add(names, { flags }) {
             )}
 `
           );
-          if (await askToContinue({ flags })) {
+          if (await askToContinue({ flags, logger })) {
             await fs.mkdir(new URL("./db", root));
             await Promise.all([
               fs.writeFile(new URL("./db/config.ts", root), STUBS.DB_CONFIG, { encoding: "utf-8" }),
@@ -558,7 +558,7 @@ ${message}`
       )
     );
   }
-  if (await askToContinue({ flags })) {
+  if (await askToContinue({ flags, logger })) {
     await fs.writeFile(fileURLToPath(configURL), output, { encoding: "utf-8" });
     logger.debug("add", `Updated astro config`);
     return 1 /* updated */;
@@ -637,7 +637,7 @@ ${boxen(coloredOutput, {
     )}
 ${message}`
   );
-  if (await askToContinue({ flags })) {
+  if (await askToContinue({ flags, logger })) {
     const spinner = yoctoSpinner({ text: "Installing dependencies..." }).start();
     try {
       await exec(installCommand.command, [...installCommand.args, ...installSpecifiers], {
@@ -659,7 +659,7 @@ ${message}`
     return 2 /* cancelled */;
   }
 }
-async function validateIntegrations(integrations, flags) {
+async function validateIntegrations(integrations, flags, logger) {
   const spinner = yoctoSpinner({ text: "Resolving packages..." }).start();
   try {
     const integrationEntries = await Promise.all(
@@ -680,7 +680,7 @@ async function validateIntegrations(integrations, flags) {
               spinner.warning(yellow(firstPartyPkgCheck.message));
             }
             spinner.warning(yellow(`${bold(integration)} is not an official Astro package.`));
-            if (!await askToContinue({ flags })) {
+            if (!await askToContinue({ flags, logger })) {
               throw new Error(
                 `No problem! Find our official integrations at ${cyan(
                   "https://astro.build/integrations"
@@ -827,7 +827,7 @@ ${message}`
       )
     );
   }
-  if (await askToContinue({ flags })) {
+  if (await askToContinue({ flags, logger })) {
     await fs.writeFile(inputConfig.tsconfigFile, output, {
       encoding: "utf-8"
     });
@@ -852,8 +852,16 @@ function parseIntegrationName(spec) {
   }
   return { scope, name, tag };
 }
-async function askToContinue({ flags }) {
+let hasHintedAboutYesFlag = false;
+async function askToContinue({
+  flags,
+  logger
+}) {
   if (flags.yes || flags.y) return true;
+  if (!hasHintedAboutYesFlag) {
+    hasHintedAboutYesFlag = true;
+    logger.info("SKIP_FORMAT", dim("  To run this command without prompts, pass the --yes flag\n"));
+  }
   const response = await prompts({
     type: "confirm",
     name: "askToContinue",
@@ -901,7 +909,7 @@ async function setupIntegrationConfig(opts) {
   ${magenta(`Astro will generate a minimal ${bold(opts.defaultConfigFile)} file.`)}
 `
     );
-    if (await askToContinue({ flags: opts.flags })) {
+    if (await askToContinue({ flags: opts.flags, logger })) {
       await fs.writeFile(
         fileURLToPath(new URL(opts.defaultConfigFile, opts.root)),
         opts.defaultConfigContent,

package/dist/cli/create-key/infra/crypto-key-generator.d.ts

@@ -1,2 +1,4 @@
 import type { KeyGenerator } from '../definitions.js';
-export declare function createCryptoKeyGenerator(): KeyGenerator;
+export declare class CryptoKeyGenerator implements KeyGenerator {
+    generate(): Promise<string>;
+}

package/dist/cli/create-key/infra/crypto-key-generator.js

@@ -1,13 +1,11 @@
 import { createKey, encodeKey } from "../../../core/encryption.js";
-function createCryptoKeyGenerator() {
-  return {
-    async generate() {
-      const key = await createKey();
-      const encoded = await encodeKey(key);
-      return encoded;
-    }
-  };
+class CryptoKeyGenerator {
+  async generate() {
+    const key = await createKey();
+    const encoded = await encodeKey(key);
+    return encoded;
+  }
 }
 export {
-  createCryptoKeyGenerator
+  CryptoKeyGenerator
 };

package/dist/cli/definitions.d.ts

@@ -1,3 +1,4 @@
+import type { StdioOptions } from 'node:child_process';
 import type { AnyCommand } from './domain/command.js';
 import type { HelpPayload } from './domain/help-payload.js';
 export interface HelpDisplay {
@@ -13,8 +14,24 @@ export interface TextStyler {
     bgGreen: (msg: string) => string;
 }
 export interface AstroVersionProvider {
-    getVersion: () => string;
+    readonly version: string;
 }
 export interface CommandRunner {
-    run: <T extends AnyCommand>(command: T, ...args: Parameters<T['run']>) => ReturnType<T['run']>;
+    run: <T extends AnyCommand>(command: T, ...args: Parameters<T['run']>) => ReturnType<T['run']> | undefined;
+}
+export interface CommandExecutorOptions {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    shell?: boolean;
+    input?: string;
+    stdio?: StdioOptions;
+}
+export interface CommandExecutor {
+    execute: (command: string, args?: Array<string>, options?: CommandExecutorOptions) => Promise<{
+        stdout: string;
+    }>;
+}
+export interface OperatingSystemProvider {
+    readonly name: NodeJS.Platform;
+    readonly displayName: string;
 }

package/dist/cli/dev/index.js

@@ -1,4 +1,4 @@
-import colors from "picocolors";
+import colors from "piccolore";
 import devServer from "../../core/dev/index.js";
 import { printHelp } from "../../core/messages.js";
 import { flagsToAstroInlineConfig } from "../flags.js";

package/dist/cli/docs/core/open-docs.d.ts

@@ -1,10 +1,12 @@
 import type { Logger } from '../../../core/logger/core.js';
-import type { CommandExecutor, PlatformProvider } from '../definitions.js';
+import type { CommandExecutor, OperatingSystemProvider } from '../../definitions.js';
+import type { CloudIdeProvider } from '../definitions.js';
 interface Options {
     url: string;
-    platformProvider: PlatformProvider;
+    operatingSystemProvider: OperatingSystemProvider;
     logger: Logger;
     commandExecutor: CommandExecutor;
+    cloudIdeProvider: CloudIdeProvider;
 }
 export declare const openDocsCommand: {
     help: {
@@ -14,6 +16,6 @@ export declare const openDocsCommand: {
         };
         description: string;
     };
-    run({ url, platformProvider, logger, commandExecutor }: Options): Promise<void>;
+    run({ url, operatingSystemProvider, logger, commandExecutor, cloudIdeProvider }: Options): Promise<void>;
 };
 export {};

package/dist/cli/docs/core/open-docs.js

@@ -10,13 +10,6 @@ function getExecInputForPlatform(platform) {
       return ["cmd", ["/c", "start"]];
     case "gitpod":
       return ["/ide/bin/remote-cli/gitpod-code", ["--openExternal"]];
-    case "aix":
-    case "freebsd":
-    case "haiku":
-    case "openbsd":
-    case "sunos":
-    case "cygwin":
-    case "netbsd":
     default:
       return null;
   }
@@ -29,8 +22,8 @@ const openDocsCommand = defineCommand({
     },
     description: `Launches the Astro Docs website directly from the terminal.`
   },
-  async run({ url, platformProvider, logger, commandExecutor }) {
-    const platform = platformProvider.get();
+  async run({ url, operatingSystemProvider, logger, commandExecutor, cloudIdeProvider }) {
+    const platform = cloudIdeProvider.name ?? operatingSystemProvider.name;
     const input = getExecInputForPlatform(platform);
     if (!input) {
       logger.error(

package/dist/cli/docs/definitions.d.ts

@@ -1,12 +1,4 @@
-import type { Platform } from './domains/platform.js';
-export interface PlatformProvider {
-    get: () => Platform;
-}
-export interface CommandExecutor {
-    execute: (command: string, args?: Array<string>, options?: {
-        cwd?: string;
-        env: Record<string, string | undefined>;
-    }) => Promise<{
-        stdout: string;
-    }>;
+import type { CloudIde } from './domain/cloud-ide.js';
+export interface CloudIdeProvider {
+    readonly name: CloudIde | null;
 }

package/dist/cli/docs/domain/cloud-ide.d.ts

@@ -0,0 +1 @@
+export type CloudIde = 'gitpod';

package/dist/cli/docs/infra/process-cloud-ide-provider.d.ts

@@ -0,0 +1,5 @@
+import type { CloudIdeProvider } from '../definitions.js';
+import type { CloudIde } from '../domain/cloud-ide.js';
+export declare class ProcessCloudIdeProvider implements CloudIdeProvider {
+    readonly name: CloudIde | null;
+}

package/dist/cli/docs/infra/process-cloud-ide-provider.js

@@ -0,0 +1,6 @@
+class ProcessCloudIdeProvider {
+  name = Boolean(process.env.GITPOD_REPO_ROOT) ? "gitpod" : null;
+}
+export {
+  ProcessCloudIdeProvider
+};

package/dist/cli/flags.d.ts

@@ -2,6 +2,7 @@ import type { Arguments } from 'yargs-parser';
 import { Logger } from '../core/logger/core.js';
 import type { AstroInlineConfig } from '../types/public/config.js';
 export type Flags = Arguments;
+/** @deprecated Use AstroConfigResolver instead */
 export declare function flagsToAstroInlineConfig(flags: Flags): AstroInlineConfig;
 /**
  * The `logging` is usually created from an `AstroInlineConfig`, but some flows like `add`

package/dist/cli/index.js

@@ -28,27 +28,26 @@ function resolveCommand(flags) {
 async function runCommand(cmd, flags) {
   const [
     { createLoggerFromFlags },
-    { createPicocolorsTextStyler },
-    { createBuildTimeAstroVersionProvider },
-    { createLoggerHelpDisplay },
-    { createCliCommandRunner }
+    { piccoloreTextStyler: textStyler },
+    { BuildTimeAstroVersionProvider },
+    { LoggerHelpDisplay },
+    { CliCommandRunner }
   ] = await Promise.all([
     import("./flags.js"),
-    import("./infra/picocolors-text-styler.js"),
+    import("./infra/piccolore-text-styler.js"),
     import("./infra/build-time-astro-version-provider.js"),
     import("./infra/logger-help-display.js"),
     import("./infra/cli-command-runner.js")
   ]);
   const logger = createLoggerFromFlags(flags);
-  const textStyler = createPicocolorsTextStyler();
-  const astroVersionProvider = createBuildTimeAstroVersionProvider();
-  const helpDisplay = createLoggerHelpDisplay({
+  const astroVersionProvider = new BuildTimeAstroVersionProvider();
+  const helpDisplay = new LoggerHelpDisplay({
     logger,
     flags,
     textStyler,
     astroVersionProvider
   });
-  const runner = createCliCommandRunner({ helpDisplay });
+  const runner = new CliCommandRunner({ helpDisplay });
   switch (cmd) {
     /** Display --help flag */
     case "help": {
@@ -66,35 +65,93 @@ async function runCommand(cmd, flags) {
       return;
     }
     case "info": {
-      const { printInfo } = await import("./info/index.js");
-      await printInfo({ flags });
-      return;
+      const [
+        { ProcessOperatingSystemProvider },
+        { CliAstroConfigResolver },
+        { ProcessPackageManagerUserAgentProvider },
+        { ProcessNodeVersionProvider },
+        { CliDebugInfoProvider },
+        { TinyexecCommandExecutor },
+        { getPackageManager },
+        { StyledDebugInfoFormatter },
+        { PromptsPrompt },
+        { CliClipboard },
+        { PassthroughTextStyler },
+        { infoCommand }
+      ] = await Promise.all([
+        import("./infra/process-operating-system-provider.js"),
+        import("./info/infra/cli-astro-config-resolver.js"),
+        import("./info/infra/process-package-manager-user-agent-provider.js"),
+        import("./info/infra/process-node-version-provider.js"),
+        import("./info/infra/cli-debug-info-provider.js"),
+        import("./infra/tinyexec-command-executor.js"),
+        import("./info/core/get-package-manager.js"),
+        import("./info/infra/styled-debug-info-formatter.js"),
+        import("./info/infra/prompts-prompt.js"),
+        import("./info/infra/cli-clipboard.js"),
+        import("./infra/passthrough-text-styler.js"),
+        import("./info/core/info.js")
+      ]);
+      const operatingSystemProvider = new ProcessOperatingSystemProvider();
+      const astroConfigResolver = new CliAstroConfigResolver({ flags });
+      const commandExecutor = new TinyexecCommandExecutor();
+      const packageManagerUserAgentProvider = new ProcessPackageManagerUserAgentProvider();
+      const nodeVersionProvider = new ProcessNodeVersionProvider();
+      const debugInfoProvider = new CliDebugInfoProvider({
+        config: await astroConfigResolver.resolve(),
+        astroVersionProvider,
+        operatingSystemProvider,
+        packageManager: await getPackageManager({
+          packageManagerUserAgentProvider,
+          commandExecutor
+        }),
+        nodeVersionProvider
+      });
+      const prompt = new PromptsPrompt({ force: flags.copy });
+      const clipboard = new CliClipboard({
+        commandExecutor,
+        logger,
+        operatingSystemProvider,
+        prompt
+      });
+      return await runner.run(infoCommand, {
+        logger,
+        debugInfoProvider,
+        getDebugInfoFormatter: ({ pretty }) => new StyledDebugInfoFormatter({
+          textStyler: pretty ? textStyler : new PassthroughTextStyler()
+        }),
+        clipboard
+      });
     }
     case "create-key": {
-      const [{ createCryptoKeyGenerator }, { createKeyCommand }] = await Promise.all([
+      const [{ CryptoKeyGenerator }, { createKeyCommand }] = await Promise.all([
         import("./create-key/infra/crypto-key-generator.js"),
         import("./create-key/core/create-key.js")
       ]);
-      const keyGenerator = createCryptoKeyGenerator();
+      const keyGenerator = new CryptoKeyGenerator();
       return await runner.run(createKeyCommand, { logger, keyGenerator });
     }
     case "docs": {
       const [
-        { createTinyexecCommandExecutor },
-        { createProcessPlatformProvider },
+        { TinyexecCommandExecutor },
+        { ProcessOperatingSystemProvider },
+        { ProcessCloudIdeProvider },
         { openDocsCommand }
       ] = await Promise.all([
-        import("./docs/infra/tinyexec-command-executor.js"),
-        import("./docs/infra/process-platform-provider.js"),
+        import("./infra/tinyexec-command-executor.js"),
+        import("./infra/process-operating-system-provider.js"),
+        import("./docs/infra/process-cloud-ide-provider.js"),
         import("./docs/core/open-docs.js")
       ]);
-      const commandExecutor = createTinyexecCommandExecutor();
-      const platformProvider = createProcessPlatformProvider();
+      const commandExecutor = new TinyexecCommandExecutor();
+      const operatingSystemProvider = new ProcessOperatingSystemProvider();
+      const cloudIdeProvider = new ProcessCloudIdeProvider();
       return await runner.run(openDocsCommand, {
         url: "https://docs.astro.build/",
         logger,
         commandExecutor,
-        platformProvider
+        operatingSystemProvider,
+        cloudIdeProvider
       });
     }
     case "telemetry": {

package/dist/cli/info/core/get-package-manager.d.ts

@@ -0,0 +1,8 @@
+import type { CommandExecutor } from '../../definitions.js';
+import type { PackageManager, PackageManagerUserAgentProvider } from '../definitions.js';
+interface Options {
+    packageManagerUserAgentProvider: PackageManagerUserAgentProvider;
+    commandExecutor: CommandExecutor;
+}
+export declare function getPackageManager({ packageManagerUserAgentProvider, commandExecutor, }: Options): Promise<PackageManager>;
+export {};

package/dist/cli/info/core/get-package-manager.js

@@ -0,0 +1,37 @@
+async function getPackageManager({
+  packageManagerUserAgentProvider,
+  commandExecutor
+}) {
+  if (!packageManagerUserAgentProvider.userAgent) {
+    const { NoopPackageManager } = await import("../infra/noop-package-manager.js");
+    return new NoopPackageManager();
+  }
+  const specifier = packageManagerUserAgentProvider.userAgent.split(" ")[0];
+  const _name = specifier.substring(0, specifier.lastIndexOf("/"));
+  const name = _name === "npminstall" ? "cnpm" : _name;
+  switch (name) {
+    case "pnpm": {
+      const { PnpmPackageManager } = await import("../infra/pnpm-package-manager.js");
+      return new PnpmPackageManager({ commandExecutor });
+    }
+    case "npm": {
+      const { NpmPackageManager } = await import("../infra/npm-package-manager.js");
+      return new NpmPackageManager({ commandExecutor });
+    }
+    case "yarn": {
+      const { YarnPackageManager } = await import("../infra/yarn-package-manager.js");
+      return new YarnPackageManager({ commandExecutor });
+    }
+    case "bun": {
+      const { BunPackageManager } = await import("../infra/bun-package-manager.js");
+      return new BunPackageManager();
+    }
+    default: {
+      const { NoopPackageManager } = await import("../infra/noop-package-manager.js");
+      return new NoopPackageManager();
+    }
+  }
+}
+export {
+  getPackageManager
+};

package/dist/cli/info/core/info.d.ts

@@ -0,0 +1,21 @@
+import type { Logger } from '../../../core/logger/core.js';
+import type { Clipboard, DebugInfoFormatter, DebugInfoProvider } from '../definitions.js';
+interface Options {
+    debugInfoProvider: DebugInfoProvider;
+    getDebugInfoFormatter: (options: {
+        pretty: boolean;
+    }) => DebugInfoFormatter;
+    logger: Logger;
+    clipboard: Clipboard;
+}
+export declare const infoCommand: {
+    help: {
+        commandName: string;
+        tables: {
+            Flags: [string, string][];
+        };
+        description: string;
+    };
+    run({ debugInfoProvider, getDebugInfoFormatter, logger, clipboard }: Options): Promise<void>;
+};
+export {};

package/dist/cli/info/core/info.js

@@ -0,0 +1,21 @@
+import { defineCommand } from "../../domain/command.js";
+const infoCommand = defineCommand({
+  help: {
+    commandName: "astro info",
+    tables: {
+      Flags: [
+        ["--help (-h)", "See all available flags."],
+        ["--copy", "Force copy of the output."]
+      ]
+    },
+    description: "Reports useful information about your current Astro environment. Useful for providing information when opening an issue."
+  },
+  async run({ debugInfoProvider, getDebugInfoFormatter, logger, clipboard }) {
+    const debugInfo = await debugInfoProvider.get();
+    logger.info("SKIP_FORMAT", getDebugInfoFormatter({ pretty: true }).format(debugInfo));
+    await clipboard.copy(getDebugInfoFormatter({ pretty: false }).format(debugInfo));
+  }
+});
+export {
+  infoCommand
+};

package/dist/cli/info/definitions.d.ts

@@ -0,0 +1,30 @@
+import type { AstroConfig } from '../../types/public/index.js';
+import type { DebugInfo } from './domain/debug-info.js';
+export interface DebugInfoProvider {
+    get: () => Promise<DebugInfo>;
+}
+export interface DebugInfoFormatter {
+    format: (info: DebugInfo) => string;
+}
+export interface Clipboard {
+    copy: (text: string) => Promise<void>;
+}
+export interface PackageManager {
+    readonly name: string;
+    getPackageVersion: (name: string) => Promise<string | undefined>;
+}
+export interface AstroConfigResolver {
+    resolve: () => Promise<AstroConfig>;
+}
+export interface Prompt {
+    confirm: (input: {
+        message: string;
+        defaultValue?: boolean;
+    }) => Promise<boolean>;
+}
+export interface PackageManagerUserAgentProvider {
+    readonly userAgent: string | null;
+}
+export interface NodeVersionProvider {
+    readonly version: string;
+}

package/dist/cli/info/domain/debug-info.d.ts

@@ -0,0 +1 @@
+export type DebugInfo = Array<[string, string | Array<string>]>;

package/dist/cli/info/infra/bun-package-manager.d.ts

@@ -0,0 +1,5 @@
+import type { PackageManager } from '../definitions.js';
+export declare class BunPackageManager implements PackageManager {
+    readonly name: string;
+    getPackageVersion(): Promise<string | undefined>;
+}

package/dist/cli/info/infra/bun-package-manager.js

@@ -0,0 +1,9 @@
+class BunPackageManager {
+  name = "bun";
+  async getPackageVersion() {
+    return void 0;
+  }
+}
+export {
+  BunPackageManager
+};

package/dist/cli/info/infra/cli-astro-config-resolver.d.ts

@@ -0,0 +1,10 @@
+import type { AstroConfig } from '../../../types/public/index.js';
+import type { Flags } from '../../flags.js';
+import type { AstroConfigResolver } from '../definitions.js';
+export declare class CliAstroConfigResolver implements AstroConfigResolver {
+    #private;
+    constructor({ flags }: {
+        flags: Flags;
+    });
+    resolve(): Promise<AstroConfig>;
+}

package/dist/cli/info/infra/cli-astro-config-resolver.js

@@ -0,0 +1,36 @@
+import { resolveConfig } from "../../../core/config/config.js";
+class CliAstroConfigResolver {
+  // TODO: find something better
+  #flags;
+  constructor({ flags }) {
+    this.#flags = flags;
+  }
+  async resolve() {
+    const { astroConfig } = await resolveConfig(
+      // TODO: consider testing flags => astro inline config
+      {
+        // Inline-only configs
+        configFile: typeof this.#flags.config === "string" ? this.#flags.config : void 0,
+        mode: typeof this.#flags.mode === "string" ? this.#flags.mode : void 0,
+        logLevel: this.#flags.verbose ? "debug" : this.#flags.silent ? "silent" : void 0,
+        force: this.#flags.force ? true : void 0,
+        // Astro user configs
+        root: typeof this.#flags.root === "string" ? this.#flags.root : void 0,
+        site: typeof this.#flags.site === "string" ? this.#flags.site : void 0,
+        base: typeof this.#flags.base === "string" ? this.#flags.base : void 0,
+        outDir: typeof this.#flags.outDir === "string" ? this.#flags.outDir : void 0,
+        server: {
+          port: typeof this.#flags.port === "number" ? this.#flags.port : void 0,
+          host: typeof this.#flags.host === "string" || typeof this.#flags.host === "boolean" ? this.#flags.host : void 0,
+          open: typeof this.#flags.open === "string" || typeof this.#flags.open === "boolean" ? this.#flags.open : void 0,
+          allowedHosts: typeof this.#flags.allowedHosts === "string" ? this.#flags.allowedHosts.split(",") : typeof this.#flags.allowedHosts === "boolean" && this.#flags.allowedHosts === true ? this.#flags.allowedHosts : []
+        }
+      },
+      "info"
+    );
+    return astroConfig;
+  }
+}
+export {
+  CliAstroConfigResolver
+};

package/dist/cli/info/infra/cli-clipboard.d.ts

@@ -0,0 +1,13 @@
+import type { Logger } from '../../../core/logger/core.js';
+import type { CommandExecutor, OperatingSystemProvider } from '../../definitions.js';
+import type { Clipboard, Prompt } from '../definitions.js';
+export declare class CliClipboard implements Clipboard {
+    #private;
+    constructor({ operatingSystemProvider, commandExecutor, logger, prompt, }: {
+        operatingSystemProvider: OperatingSystemProvider;
+        commandExecutor: CommandExecutor;
+        logger: Logger;
+        prompt: Prompt;
+    });
+    copy(text: string): Promise<void>;
+}