astro 6.0.0-alpha.0 → 6.0.0-alpha.2

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>;
+}

package/dist/cli/info/infra/cli-clipboard.js

@@ -0,0 +1,78 @@
+async function getExecInputForPlatform({
+  platform,
+  commandExecutor
+}) {
+  if (platform === "darwin") {
+    return ["pbcopy"];
+  }
+  if (platform === "win32") {
+    return ["clip"];
+  }
+  const unixCommands = [
+    ["xclip", ["-selection", "clipboard"]],
+    ["wl-copy", []]
+  ];
+  for (const [unixCommand, unixArgs] of unixCommands) {
+    try {
+      const { stdout } = await commandExecutor.execute("which", [unixCommand]);
+      if (stdout.trim()) {
+        return [unixCommand, unixArgs];
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+class CliClipboard {
+  #operatingSystemProvider;
+  #commandExecutor;
+  #logger;
+  #prompt;
+  constructor({
+    operatingSystemProvider,
+    commandExecutor,
+    logger,
+    prompt
+  }) {
+    this.#operatingSystemProvider = operatingSystemProvider;
+    this.#commandExecutor = commandExecutor;
+    this.#logger = logger;
+    this.#prompt = prompt;
+  }
+  async copy(text) {
+    text = text.trim();
+    const platform = this.#operatingSystemProvider.name;
+    const input = await getExecInputForPlatform({
+      platform,
+      commandExecutor: this.#commandExecutor
+    });
+    if (!input) {
+      this.#logger.warn("SKIP_FORMAT", "Clipboard command not found!");
+      this.#logger.info("SKIP_FORMAT", "Please manually copy the text above.");
+      return;
+    }
+    if (!await this.#prompt.confirm({
+      message: "Copy to clipboard?",
+      defaultValue: true
+    })) {
+      return;
+    }
+    try {
+      const [command, args] = input;
+      await this.#commandExecutor.execute(command, args, {
+        input: text,
+        stdio: ["pipe", "ignore", "ignore"]
+      });
+      this.#logger.info("SKIP_FORMAT", "Copied to clipboard!");
+    } catch {
+      this.#logger.error(
+        "SKIP_FORMAT",
+        "Sorry, something went wrong! Please copy the text above manually."
+      );
+    }
+  }
+}
+export {
+  CliClipboard
+};

package/dist/cli/info/infra/cli-debug-info-provider.d.ts

@@ -0,0 +1,15 @@
+import type { AstroConfig } from '../../../types/public/index.js';
+import type { AstroVersionProvider, OperatingSystemProvider } from '../../definitions.js';
+import type { DebugInfoProvider, NodeVersionProvider, PackageManager } from '../definitions.js';
+import type { DebugInfo } from '../domain/debug-info.js';
+export declare class CliDebugInfoProvider implements DebugInfoProvider {
+    #private;
+    constructor({ config, astroVersionProvider, packageManager, operatingSystemProvider, nodeVersionProvider, }: {
+        config: Pick<AstroConfig, 'output' | 'adapter' | 'integrations'>;
+        astroVersionProvider: AstroVersionProvider;
+        packageManager: PackageManager;
+        operatingSystemProvider: OperatingSystemProvider;
+        nodeVersionProvider: NodeVersionProvider;
+    });
+    get(): Promise<DebugInfo>;
+}

package/dist/cli/info/infra/cli-debug-info-provider.js

@@ -0,0 +1,57 @@
+function withVersion(name, version) {
+  let result = name;
+  if (version) {
+    result += ` (${version})`;
+  }
+  return result;
+}
+class CliDebugInfoProvider {
+  #config;
+  #astroVersionProvider;
+  #packageManager;
+  #operatingSystemProvider;
+  #nodeVersionProvider;
+  constructor({
+    config,
+    astroVersionProvider,
+    packageManager,
+    operatingSystemProvider,
+    nodeVersionProvider
+  }) {
+    this.#config = config;
+    this.#astroVersionProvider = astroVersionProvider;
+    this.#packageManager = packageManager;
+    this.#operatingSystemProvider = operatingSystemProvider;
+    this.#nodeVersionProvider = nodeVersionProvider;
+  }
+  async get() {
+    const debugInfo = [
+      ["Astro", `v${this.#astroVersionProvider.version}`],
+      ["Node", this.#nodeVersionProvider.version],
+      ["System", this.#operatingSystemProvider.displayName],
+      ["Package Manager", this.#packageManager.name],
+      ["Output", this.#config.output]
+    ];
+    const viteVersion = await this.#packageManager.getPackageVersion("vite");
+    if (viteVersion) {
+      debugInfo.splice(1, 0, ["Vite", viteVersion]);
+    }
+    debugInfo.push([
+      "Adapter",
+      this.#config.adapter ? withVersion(
+        this.#config.adapter.name,
+        await this.#packageManager.getPackageVersion(this.#config.adapter.name)
+      ) : "none"
+    ]);
+    const integrations = await Promise.all(
+      this.#config.integrations.map(
+        async ({ name }) => withVersion(name, await this.#packageManager.getPackageVersion(name))
+      )
+    );
+    debugInfo.push(["Integrations", integrations.length > 0 ? integrations : "none"]);
+    return debugInfo;
+  }
+}
+export {
+  CliDebugInfoProvider
+};

package/dist/cli/info/infra/dev-debug-info-provider.d.ts

@@ -0,0 +1,18 @@
+import type { AstroConfig } from '../../../types/public/index.js';
+import type { AstroVersionProvider, OperatingSystemProvider } from '../../definitions.js';
+import type { DebugInfoProvider, NodeVersionProvider, PackageManager } from '../definitions.js';
+import type { DebugInfo } from '../domain/debug-info.js';
+/**
+ * Returns debug info without any package versions, to avoid slowing down the dev server
+ */
+export declare class DevDebugInfoProvider implements DebugInfoProvider {
+    #private;
+    constructor({ config, astroVersionProvider, packageManager, operatingSystemProvider, nodeVersionProvider, }: {
+        config: Pick<AstroConfig, 'output' | 'adapter' | 'integrations'>;
+        astroVersionProvider: AstroVersionProvider;
+        packageManager: PackageManager;
+        operatingSystemProvider: OperatingSystemProvider;
+        nodeVersionProvider: NodeVersionProvider;
+    });
+    get(): Promise<DebugInfo>;
+}

package/dist/cli/info/infra/dev-debug-info-provider.js

@@ -0,0 +1,36 @@
+class DevDebugInfoProvider {
+  #config;
+  #astroVersionProvider;
+  #packageManager;
+  #operatingSystemProvider;
+  #nodeVersionProvider;
+  constructor({
+    config,
+    astroVersionProvider,
+    packageManager,
+    operatingSystemProvider,
+    nodeVersionProvider
+  }) {
+    this.#config = config;
+    this.#astroVersionProvider = astroVersionProvider;
+    this.#packageManager = packageManager;
+    this.#operatingSystemProvider = operatingSystemProvider;
+    this.#nodeVersionProvider = nodeVersionProvider;
+  }
+  async get() {
+    const debugInfo = [
+      ["Astro", `v${this.#astroVersionProvider.version}`],
+      ["Node", this.#nodeVersionProvider.version],
+      ["System", this.#operatingSystemProvider.displayName],
+      ["Package Manager", this.#packageManager.name],
+      ["Output", this.#config.output],
+      ["Adapter", this.#config.adapter?.name ?? "none"]
+    ];
+    const integrations = this.#config.integrations.map((integration) => integration.name);
+    debugInfo.push(["Integrations", integrations.length > 0 ? integrations : "none"]);
+    return debugInfo;
+  }
+}
+export {
+  DevDebugInfoProvider
+};

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

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

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

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

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

@@ -0,0 +1,10 @@
+import type { CommandExecutor } from '../../definitions.js';
+import type { PackageManager } from '../definitions.js';
+export declare class NpmPackageManager implements PackageManager {
+    #private;
+    readonly name: string;
+    constructor({ commandExecutor }: {
+        commandExecutor: CommandExecutor;
+    });
+    getPackageVersion(name: string): Promise<string | undefined>;
+}