astro 7.2.9 → 7.3.0

package/dist/assets/build/generate.d.ts

@@ -1,5 +1,5 @@
 import type { StaticBuildOptions } from '../../core/build/types.js';
-import type { AstroLogger } from '../../core/logger/core.js';
+import { type AstroLogger } from '../../core/logger/core.js';
 import type { MapValue } from '../../type-utils.js';
 import type { AstroConfig } from '../../types/public/config.js';
 import type { AssetsGlobalStaticImagesList, SerializedStaticImage } from '../types.js';

package/dist/assets/build/generate.js

@@ -4,6 +4,7 @@ import colors from "piccolore";
 import { getTimeStat } from "../../core/build/util.js";
 import { AstroError } from "../../core/errors/errors.js";
 import { AstroErrorData } from "../../core/errors/index.js";
+import { astroToRuntimeLogger } from "../../core/logger/core.js";
 import { isRemotePath, removeLeadingForwardSlash } from "../../core/path.js";
 import { getClientOutputDirectory } from "../../prerender/utils.js";
 import { getConfiguredImageService } from "../internal.js";
@@ -165,7 +166,8 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env) {
       resultData.data = (await imageService.transform(
         originalImage.data,
         { ...options, src: originalImagePath },
-        env.imageConfig
+        env.imageConfig,
+        astroToRuntimeLogger(env.logger)
       )).data;
     } catch (e) {
       if (AstroError.is(e)) {

package/dist/assets/endpoint/dev.js

@@ -44,16 +44,17 @@ async function loadLocalImage(src, url) {
   }
   return returnValue;
 }
-const GET = async ({ request }) => {
+const GET = async ({ request, logger }) => {
   if (!import.meta.env.DEV) {
-    console.error("The dev image endpoint can only be used in dev mode.");
+    logger.error("The dev image endpoint can only be used in dev mode.");
     return new Response("Invalid endpoint", { status: 500 });
   }
   try {
-    return await handleImageRequest({ request, loadLocalImage });
+    return await handleImageRequest({ request, loadLocalImage, logger });
   } catch (err) {
-    console.error("Could not process image request:", err);
-    return new Response(`Could not process image request: ${err}`, {
+    const message = `Could not process image request: ${err}`;
+    logger.error(message);
+    return new Response(message, {
       status: 500
     });
   }

package/dist/assets/endpoint/generic.js

@@ -5,14 +5,14 @@ import * as mime from "mrmime";
 import { getConfiguredImageService } from "../internal.js";
 import { etag } from "../utils/etag.js";
 import { loadImage } from "./loadImage.js";
-const GET = async ({ request }) => {
+const GET = async ({ request, logger }) => {
   try {
     const imageService = await getConfiguredImageService();
     if (!("transform" in imageService)) {
       throw new Error("Configured image service is not a local service");
     }
     const url = new URL(request.url);
-    const transform = await imageService.parseURL(url, imageConfig);
+    const transform = await imageService.parseURL(url, imageConfig, logger);
     if (!transform?.src) {
       throw new Error("Incorrect transform returned by `parseURL`");
     }
@@ -37,7 +37,8 @@ const GET = async ({ request }) => {
     const { data, format } = await imageService.transform(
       new Uint8Array(inputBuffer),
       transform,
-      imageConfig
+      imageConfig,
+      logger
     );
     return new Response(data, {
       status: 200,
@@ -49,7 +50,7 @@ const GET = async ({ request }) => {
       }
     });
   } catch (err) {
-    console.error("Could not process image request:", err);
+    logger.error(`Could not process image request: ${err}`);
     return new Response("Internal Server Error", { status: 500 });
   }
 };

package/dist/assets/endpoint/node.js

@@ -26,11 +26,11 @@ async function loadLocalImage(src, url) {
     return void 0;
   }
 }
-const GET = async ({ request }) => {
+const GET = async ({ request, logger }) => {
   try {
-    return await handleImageRequest({ request, loadLocalImage });
+    return await handleImageRequest({ request, loadLocalImage, logger });
   } catch (err) {
-    console.error("Could not process image request:", err);
+    logger.error(`Could not process image request: ${err}`);
     return new Response("Internal Server Error", {
       status: 500
     });

package/dist/assets/endpoint/shared.d.ts

@@ -1,5 +1,7 @@
+import type { AstroRuntimeLogger } from '../../types/public/context.js';
 export declare function loadRemoteImage(src: URL): Promise<Buffer | undefined>;
-export declare const handleImageRequest: ({ request, loadLocalImage, }: {
+export declare const handleImageRequest: ({ request, loadLocalImage, logger, }: {
     request: Request;
     loadLocalImage: (src: string, baseUrl: URL) => Promise<Buffer | undefined>;
+    logger: AstroRuntimeLogger;
 }) => Promise<Response>;

package/dist/assets/endpoint/shared.js

@@ -26,14 +26,15 @@ async function loadRemoteImage(src) {
 }
 const handleImageRequest = async ({
   request,
-  loadLocalImage
+  loadLocalImage,
+  logger
 }) => {
   const imageService = await getConfiguredImageService();
   if (!("transform" in imageService)) {
     throw new Error("Configured image service is not a local service");
   }
   const url = new URL(request.url);
-  const transform = await imageService.parseURL(url, imageConfig);
+  const transform = await imageService.parseURL(url, imageConfig, logger);
   if (!transform?.src) {
     return new Response("Invalid request", { status: 400 });
   }
@@ -55,7 +56,12 @@ const handleImageRequest = async ({
   if (!inputBuffer) {
     return new Response("Internal Server Error", { status: 500 });
   }
-  const { data, format } = await imageService.transform(inputBuffer, transform, imageConfig);
+  const { data, format } = await imageService.transform(
+    inputBuffer,
+    transform,
+    imageConfig,
+    logger
+  );
   return new Response(data, {
     status: 200,
     headers: {

package/dist/assets/fonts/config.d.ts

@@ -7,8 +7,8 @@ export declare const StyleSchema: z.ZodEnum<{
     oblique: "oblique";
 }>;
 export declare const DisplaySchema: z.ZodEnum<{
-    auto: "auto";
     optional: "optional";
+    auto: "auto";
     fallback: "fallback";
     block: "block";
     swap: "swap";
@@ -45,8 +45,8 @@ export declare const FontFamilySchema: z.ZodObject<{
     fallbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
     optimizedFallbacks: z.ZodOptional<z.ZodBoolean>;
     display: z.ZodOptional<z.ZodEnum<{
-        auto: "auto";
         optional: "optional";
+        auto: "auto";
         fallback: "fallback";
         block: "block";
         swap: "swap";

package/dist/assets/internal.d.ts

@@ -1,8 +1,9 @@
 import type { AstroConfig } from '../types/public/config.js';
+import type { AstroRuntimeLogger } from '../types/public/context.js';
 import type { AstroAdapterClientConfig } from '../types/public/integrations.js';
 import { type ImageService } from './services/service.js';
 import { type GetImageResult, type UnresolvedImageTransform } from './types.js';
 export { verifyOptions } from './services/service.js';
 export declare const cssFitValues: string[];
 export declare function getConfiguredImageService(): Promise<ImageService>;
-export declare function getImage(options: UnresolvedImageTransform, imageConfig: AstroConfig['image'] & AstroAdapterClientConfig): Promise<GetImageResult>;
+export declare function getImage(options: UnresolvedImageTransform, imageConfig: AstroConfig['image'] & AstroAdapterClientConfig, logger: AstroRuntimeLogger): Promise<GetImageResult>;

package/dist/assets/internal.js

@@ -34,7 +34,7 @@ async function getConfiguredImageService() {
   }
   return globalThis.astroAsset.imageService;
 }
-async function getImage(options, imageConfig) {
+async function getImage(options, imageConfig, logger) {
   if (!options || typeof options !== "object") {
     throw new AstroError({
       ...AstroErrorData.ExpectedImageOptions,
@@ -70,7 +70,7 @@ async function getImage(options, imageConfig) {
           message: AstroErrorData.RemoteImageNotAllowed.message(resolvedOptions.src)
         });
       }
-      const getRemoteSize = (url) => service.getRemoteSize?.(url, imageConfig) ?? inferRemoteSize(url, imageConfig);
+      const getRemoteSize = (url) => service.getRemoteSize?.(url, imageConfig, logger) ?? inferRemoteSize(url, imageConfig);
       const result = await getRemoteSize(resolvedOptions.src);
       resolvedOptions.width ??= result.width;
       resolvedOptions.height ??= result.height;
@@ -129,25 +129,26 @@ async function getImage(options, imageConfig) {
     const currentPosition = resolvedOptions.position || "center";
     resolvedOptions["data-astro-image-pos"] = currentPosition.replace(/\s+/g, "-");
   }
-  const validatedOptions = service.validateOptions ? await service.validateOptions(resolvedOptions, imageConfig) : resolvedOptions;
+  const validatedOptions = service.validateOptions ? await service.validateOptions(resolvedOptions, imageConfig, logger) : resolvedOptions;
   validatedOptions.format ??= await peekRemoteFormatForStaticEmit(
     validatedOptions,
     imageConfig,
-    service
+    service,
+    logger
   );
-  const srcSetTransforms = service.getSrcSet ? await service.getSrcSet(validatedOptions, imageConfig) : [];
+  const srcSetTransforms = service.getSrcSet ? await service.getSrcSet(validatedOptions, imageConfig, logger) : [];
   const lazyImageURLFactory = (getValue) => {
     let cached = null;
     return () => cached ??= getValue();
   };
-  const initialImageURL = await service.getURL(validatedOptions, imageConfig);
+  const initialImageURL = await service.getURL(validatedOptions, imageConfig, logger);
   let lazyImageURL = lazyImageURLFactory(() => initialImageURL);
   const matchesValidatedTransform = (transform) => transform.width === validatedOptions.width && transform.height === validatedOptions.height && transform.format === validatedOptions.format;
   let srcSets = await Promise.all(
     srcSetTransforms.map(async (srcSet) => {
       return {
         transform: srcSet.transform,
-        url: matchesValidatedTransform(srcSet.transform) ? initialImageURL : await service.getURL(srcSet.transform, imageConfig),
+        url: matchesValidatedTransform(srcSet.transform) ? initialImageURL : await service.getURL(srcSet.transform, imageConfig, logger),
         descriptor: srcSet.descriptor,
         attributes: srcSet.attributes
       };
@@ -193,15 +194,15 @@ async function getImage(options, imageConfig) {
       values: srcSets,
       attribute: srcSets.map((srcSet) => `${srcSet.url} ${srcSet.descriptor}`).join(", ")
     },
-    attributes: service.getHTMLAttributes !== void 0 ? await service.getHTMLAttributes(validatedOptions, imageConfig) : {}
+    attributes: service.getHTMLAttributes !== void 0 ? await service.getHTMLAttributes(validatedOptions, imageConfig, logger) : {}
   };
 }
-async function peekRemoteFormatForStaticEmit(options, imageConfig, service) {
+async function peekRemoteFormatForStaticEmit(options, imageConfig, service, logger) {
   if (!isRemoteImage(options.src) || !isRemoteAllowed(options.src, imageConfig) || !globalThis.astroAsset?.addStaticImage || !isLocalService(service) || !service.getRemoteSize) {
     return void 0;
   }
   try {
-    const probed = await service.getRemoteSize(options.src, imageConfig);
+    const probed = await service.getRemoteSize(options.src, imageConfig, logger);
     return resolveDefaultOutputFormat(probed.format);
   } catch {
     return void 0;

package/dist/assets/services/service.d.ts

@@ -1,5 +1,6 @@
 import type { AstroConfig } from '../../types/public/config.js';
 import type { ImageFit, ImageMetadata, ImageOutputFormat, ImageTransform, UnresolvedSrcSetValue } from '../types.js';
+import type { AstroRuntimeLogger } from '../../types/public/context.js';
 export type ImageService = LocalImageService | ExternalImageService;
 export declare function isLocalService(service: ImageService | undefined): service is LocalImageService;
 export declare function parseQuality(quality: string): string | number;
@@ -19,21 +20,21 @@ interface SharedServiceProps<T extends Record<string, any> = Record<string, any>
      * For external services, this should point to the URL your images are coming from, for instance, `/_vercel/image`
      *
      */
-    getURL: (options: ImageTransform, imageConfig: ImageConfig<T>) => string | Promise<string>;
+    getURL: (options: ImageTransform, imageConfig: ImageConfig<T>, logger: AstroRuntimeLogger) => string | Promise<string>;
     /**
      * Generate additional `srcset` values for the image.
      *
      * While in most cases this is exclusively used for `srcset`, it can also be used in a more generic way to generate
      * multiple variants of the same image. For instance, you can use this to generate multiple aspect ratios or multiple formats.
      */
-    getSrcSet?: (options: ImageTransform, imageConfig: ImageConfig<T>) => UnresolvedSrcSetValue[] | Promise<UnresolvedSrcSetValue[]>;
+    getSrcSet?: (options: ImageTransform, imageConfig: ImageConfig<T>, logger: AstroRuntimeLogger) => UnresolvedSrcSetValue[] | Promise<UnresolvedSrcSetValue[]>;
     /**
      * Return any additional HTML attributes separate from `src` that your service requires to show the image properly.
      *
      * For example, you might want to return the `width` and `height` to avoid CLS, or a particular `class` or `style`.
      * In most cases, you'll want to return directly what your user supplied you, minus the attributes that were used to generate the image.
      */
-    getHTMLAttributes?: (options: ImageTransform, imageConfig: ImageConfig<T>) => Record<string, any> | Promise<Record<string, any>>;
+    getHTMLAttributes?: (options: ImageTransform, imageConfig: ImageConfig<T>, logger: AstroRuntimeLogger) => Record<string, any> | Promise<Record<string, any>>;
     /**
      * Validate and return the options passed by the user.
      *
@@ -42,14 +43,14 @@ interface SharedServiceProps<T extends Record<string, any> = Record<string, any>
      *
      * This method should returns options, and can be used to set defaults (ex: a default output format to be used if the user didn't specify one.)
      */
-    validateOptions?: (options: ImageTransform, imageConfig: ImageConfig<T>) => ImageTransform | Promise<ImageTransform>;
+    validateOptions?: (options: ImageTransform, imageConfig: ImageConfig<T>, logger: AstroRuntimeLogger) => ImageTransform | Promise<ImageTransform>;
     /**
      * Return the dimensions of a remote image.
      *
      * This is used to infer the width and height of an image from its URL,
      * allowing the service to provide necessary metadata when it's not available locally.
      */
-    getRemoteSize?: (url: string, imageConfig: ImageConfig<T>) => Omit<ImageMetadata, 'src' | 'fsPath'> | Promise<Omit<ImageMetadata, 'src' | 'fsPath'>>;
+    getRemoteSize?: (url: string, imageConfig: ImageConfig<T>, logger: AstroRuntimeLogger) => Omit<ImageMetadata, 'src' | 'fsPath'> | Promise<Omit<ImageMetadata, 'src' | 'fsPath'>>;
 }
 export type ExternalImageService<T extends Record<string, any> = Record<string, any>> = SharedServiceProps<T>;
 type LocalImageTransform = {
@@ -62,12 +63,12 @@ export interface LocalImageService<T extends Record<string, any> = Record<string
      *
      * In most cases, this will get query parameters using, for example, `params.get('width')` and return those.
      */
-    parseURL: (url: URL, imageConfig: ImageConfig<T>) => LocalImageTransform | undefined | Promise<LocalImageTransform> | Promise<undefined>;
+    parseURL: (url: URL, imageConfig: ImageConfig<T>, logger: AstroRuntimeLogger) => LocalImageTransform | undefined | Promise<LocalImageTransform> | Promise<undefined>;
     /**
      * Performs the image transformations on the input image and returns both the binary data and
      * final image format of the optimized image.
      */
-    transform: (inputBuffer: Uint8Array, transform: LocalImageTransform, imageConfig: ImageConfig<T>) => Promise<{
+    transform: (inputBuffer: Uint8Array, transform: LocalImageTransform, imageConfig: ImageConfig<T>, logger: AstroRuntimeLogger) => Promise<{
         data: Uint8Array;
         format: ImageOutputFormat;
     }>;

package/dist/assets/services/sharp.js

@@ -82,7 +82,7 @@ const sharpService = {
   getHTMLAttributes: baseService.getHTMLAttributes,
   getSrcSet: baseService.getSrcSet,
   getRemoteSize: baseService.getRemoteSize,
-  async transform(inputBuffer, transformOptions, config) {
+  async transform(inputBuffer, transformOptions, config, logger) {
     if (!sharp) sharp = await loadSharp();
     const transform = transformOptions;
     const kernel = config.service.config.kernel;
@@ -90,8 +90,8 @@ const sharpService = {
     const outputFormat = transform.format ?? resolveDefaultOutputFormat(bufferFormat);
     if (outputFormat === "svg") {
       if (bufferFormat && bufferFormat !== "svg") {
-        console.warn(
-          `\u26A0\uFE0F  Astro expected an SVG for "${transform.src}" but the source is ${bufferFormat}. Passing it through as ${bufferFormat} instead.`
+        logger.warn(
+          `Astro expected an SVG for "${transform.src}" but the source is ${bufferFormat}. Passing it through as ${bufferFormat} instead.`
         );
         return { data: inputBuffer, format: bufferFormat };
       }
@@ -162,8 +162,8 @@ const sharpService = {
     try {
       ({ data, info } = await result.toBuffer({ resolveWithObject: true }));
     } catch {
-      console.warn(
-        `\u26A0\uFE0F  Astro could not optimize image "${transform.src}". Sharp doesn't support this format. The image will be used unoptimized. Consider converting to WebP or placing in the public/ folder.`
+      logger.warn(
+        `Astro could not optimize image "${transform.src}". Sharp doesn't support this format. The image will be used unoptimized. Consider converting to WebP or placing in the public/ folder.`
       );
       return { data: inputBuffer, format: bufferFormat };
     }

package/dist/assets/vite-plugin-assets.js

@@ -9,7 +9,7 @@ import {
   removeBase,
   removeQueryString
 } from "../core/path.js";
-import { recordStaticImage } from "../core/build/incremental-image-collector.js";
+import { recordStaticImage } from "../core/render-scope/record.js";
 import { normalizePath } from "../core/viteUtils.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 import { isAstroServerEnvironment } from "../environments.js";
@@ -92,6 +92,21 @@ const addStaticImageFactory = (settings) => {
     return stringifyPlaceholderURL(url);
   };
 };
+const RUNTIME_LOGGER_SETUP = `
+	import { createConsoleLogger as _createConsoleLogger } from "astro/logger/console";
+	import { astroToRuntimeLogger as _astroToRuntimeLogger } from "astro/_internal/logger";
+	import _loggerDestination, { level as _loggerLevel } from "virtual:astro:logger";
+	const _astroLogger = _createConsoleLogger({ level: _loggerLevel });
+	if (_loggerDestination) _astroLogger.setDestination(_loggerDestination);
+	const _runtimeLogger = _astroToRuntimeLogger(_astroLogger);
+`;
+const CLIENT_RUNTIME_LOGGER_SETUP = `
+	const _runtimeLogger = {
+		info: (message) => console.info(message),
+		warn: (message) => console.warn(message),
+		error: (message) => console.error(message),
+	};
+`;
 function assets({ fs, settings, sync, logger }) {
   let resolvedConfig;
   let shouldEmitFile = false;
@@ -133,8 +148,9 @@ function assets({ fs, settings, sync, logger }) {
         handler(id) {
           if (id === RESOLVED_VIRTUAL_GET_IMAGE_ID) {
             const isServerEnvironment2 = isAstroServerEnvironment(this.environment);
-            const getImageExport2 = isServerEnvironment2 ? `import { getImage as getImageInternal } from "astro/assets";
-								export const getImage = async (options) => await getImageInternal(options, imageConfig);` : `import { AstroError, AstroErrorData } from "astro/errors";
+            const getImageExport2 = isServerEnvironment2 ? `${RUNTIME_LOGGER_SETUP}
+								import { getImage as getImageInternal } from "astro/assets";
+								export const getImage = async (options) => await getImageInternal(options, imageConfig, _runtimeLogger);` : `import { AstroError, AstroErrorData } from "astro/errors";
 								export const getImage = async () => {
 									throw new AstroError(
 										AstroErrorData.GetImageNotUsedOnServer.message,
@@ -158,7 +174,7 @@ function assets({ fs, settings, sync, logger }) {
           }
           const isServerEnvironment = isAstroServerEnvironment(this.environment);
           const getImageExport = isServerEnvironment ? `import { getImage as getImageInternal } from "astro/assets";
-							export const getImage = async (options) => await getImageInternal(options, imageConfig);` : `import { AstroError, AstroErrorData } from "astro/errors";
+							export const getImage = async (options) => await getImageInternal(options, imageConfig, _runtimeLogger);` : `import { AstroError, AstroErrorData } from "astro/errors";
 							export const getImage = async () => {
 								throw new AstroError(
 									AstroErrorData.GetImageNotUsedOnServer.message,
@@ -167,6 +183,7 @@ function assets({ fs, settings, sync, logger }) {
 							};`;
           return {
             code: `
+				${isServerEnvironment ? RUNTIME_LOGGER_SETUP : CLIENT_RUNTIME_LOGGER_SETUP}
 				import { getConfiguredImageService as _getConfiguredImageService } from "astro/assets";
 				export { isLocalService } from "astro/assets";
 				${settings.config.image.responsiveStyles ? `import "${VIRTUAL_IMAGE_STYLES_ID}";` : ""}
@@ -199,7 +216,7 @@ function assets({ fs, settings, sync, logger }) {
 					});
 					export const inferRemoteSize = async (url) => {
 						const service = await _getConfiguredImageService();
-						return service.getRemoteSize?.(url, imageConfig) ?? inferRemoteSizeInternal(url, imageConfig);
+						return service.getRemoteSize?.(url, imageConfig, _runtimeLogger) ?? inferRemoteSizeInternal(url, imageConfig);
 					}
 					// This is used by the @astrojs/node integration to locate images.
 					// It's unused on other platforms, but on some platforms like Netlify (and presumably also Vercel)

package/dist/cli/add/index.js

@@ -674,7 +674,9 @@ async function tryToInstallIntegrations({
     } catch (err) {
       spinner.error("Error installing dependencies.");
       logger.debug("add", "Error installing dependencies", err);
-      console.error("\n", err.stdout || err.message, "\n");
+      logger.error("add", `
+${err.stdout || err.message}
+`);
       return "failure";
     }
   } else {

package/dist/cli/index.js

@@ -170,7 +170,7 @@ async function runCommand(cmd, flags) {
     enableVerboseLogging();
   }
   const { notify } = await import("./telemetry/index.js");
-  await notify();
+  await notify(logger);
   switch (cmd) {
     case "add": {
       const { add } = await import("./add/index.js");

package/dist/cli/infra/build-time-astro-version-provider.js

@@ -1,6 +1,6 @@
 class BuildTimeAstroVersionProvider {
   // Injected during the build through esbuild define
-  version = "7.2.9";
+  version = "7.3.0";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/cli/preferences/index.js

@@ -62,7 +62,7 @@ async function preferences(subcommand, key, value, { flags }) {
     json: !!flags.json
   };
   if (subcommand === "list") {
-    return listPreferences(settings, opts);
+    return listPreferences(settings, logger, opts);
   }
   if (subcommand === "enable" || subcommand === "disable") {
     key = `${key}.enabled`;
@@ -74,7 +74,8 @@ async function preferences(subcommand, key, value, { flags }) {
   }
   if (subcommand === "set" && value === void 0) {
     const type = typeof dlv(DEFAULT_PREFERENCES, key);
-    console.error(
+    logger.error(
+      "preferences",
       msg.formatErrorMessage(
         collectErrorMetadata(new Error(`Please provide a ${type} value for "${key}"`)),
         true
@@ -84,79 +85,79 @@ async function preferences(subcommand, key, value, { flags }) {
   }
   switch (subcommand) {
     case "get":
-      return getPreference(settings, key, opts);
+      return getPreference(settings, logger, key, opts);
     case "set":
-      return setPreference(settings, key, value, opts);
+      return setPreference(settings, logger, key, value, opts);
     case "reset":
     case "delete":
-      return resetPreference(settings, key, opts);
+      return resetPreference(settings, logger, key, opts);
     case "enable":
-      return enablePreference(settings, key, opts);
+      return enablePreference(settings, logger, key, opts);
     case "disable":
-      return disablePreference(settings, key, opts);
+      return disablePreference(settings, logger, key, opts);
   }
 }
-async function getPreference(settings, key, { location = "project" }) {
+async function getPreference(settings, logger, key, { location = "project" }) {
   try {
     let value = await settings.preferences.get(key, { location });
     if (value && typeof value === "object" && !Array.isArray(value)) {
       if (Object.keys(value).length === 0) {
         value = dlv(DEFAULT_PREFERENCES, key);
-        console.log(msg.preferenceDefaultIntro(key));
+        logger.info("SKIP_FORMAT", msg.preferenceDefaultIntro(key));
       }
-      prettyPrint({ [key]: value });
+      prettyPrint(logger, { [key]: value });
       return 0;
     }
     if (value === void 0) {
       const defaultValue = await settings.preferences.get(key);
-      console.log(msg.preferenceDefault(key, defaultValue));
+      logger.info("SKIP_FORMAT", msg.preferenceDefault(key, defaultValue));
       return 0;
     }
-    console.log(msg.preferenceGet(key, value));
+    logger.info("SKIP_FORMAT", msg.preferenceGet(key, value));
     return 0;
   } catch {
   }
   return 1;
 }
-async function setPreference(settings, key, value, { location }) {
+async function setPreference(settings, logger, key, value, { location }) {
   try {
     const defaultType = typeof dlv(DEFAULT_PREFERENCES, key);
     if (typeof coerce(key, value) !== defaultType) {
       throw new Error(`${key} expects a "${defaultType}" value!`);
     }
     await settings.preferences.set(key, coerce(key, value), { location });
-    console.log(msg.preferenceSet(key, value));
+    logger.info("SKIP_FORMAT", msg.preferenceSet(key, value));
     return 0;
   } catch (e) {
     if (e instanceof Error) {
-      console.error(msg.formatErrorMessage(collectErrorMetadata(e), true));
+      logger.error("preferences", msg.formatErrorMessage(collectErrorMetadata(e), true));
       return 1;
     }
     throw e;
   }
 }
-async function enablePreference(settings, key, { location }) {
+async function enablePreference(settings, logger, key, { location }) {
   try {
     await settings.preferences.set(key, true, { location });
-    console.log(msg.preferenceEnabled(key.replace(".enabled", "")));
+    logger.info("SKIP_FORMAT", msg.preferenceEnabled(key.replace(".enabled", "")));
     return 0;
   } catch {
   }
   return 1;
 }
-async function disablePreference(settings, key, { location }) {
+async function disablePreference(settings, logger, key, { location }) {
   try {
     await settings.preferences.set(key, false, { location });
-    console.log(msg.preferenceDisabled(key.replace(".enabled", "")));
+    logger.info("SKIP_FORMAT", msg.preferenceDisabled(key.replace(".enabled", "")));
     return 0;
   } catch {
   }
   return 1;
 }
-async function resetPreference(settings, key, { location }) {
+async function resetPreference(settings, logger, key, { location }) {
   try {
     await settings.preferences.set(key, void 0, { location });
-    console.log(msg.preferenceReset(key));
+    logger.info("SKIP_FORMAT", msg.preferenceReset(key));
     return 0;
   } catch {
   }
@@ -184,10 +185,10 @@ function userValues(flatDefault, flatProject, flatGlobal) {
   }
   return result;
 }
-async function listPreferences(settings, { location, json }) {
+async function listPreferences(settings, logger, { location, json }) {
   if (json) {
     const resolved = await settings.preferences.getAll();
-    console.log(JSON.stringify(resolved, null, 2));
+    logger.info("SKIP_FORMAT", JSON.stringify(resolved, null, 2));
     return 0;
   }
   const { global, project, fromAstroConfig, defaults } = await settings.preferences.list({
@@ -201,11 +202,11 @@ async function listPreferences(settings, { location, json }) {
   if (userKeys.length > 0) {
     const badge = bgGreen(black(` Your Preferences `));
     const table = formatTable(flatUser, ["Preference", "Value"]);
-    console.log(["", badge, table].join("\n"));
+    logger.info("SKIP_FORMAT", ["", badge, table].join("\n"));
   } else {
     const badge = bgGreen(black(` Your Preferences `));
     const message = dim("No preferences set");
-    console.log(["", badge, "", message].join("\n"));
+    logger.info("SKIP_FORMAT", ["", badge, "", message].join("\n"));
   }
   const flatUnset = annotate(Object.assign({}, flatDefault), "");
   for (const key of userKeys) {
@@ -215,14 +216,15 @@ async function listPreferences(settings, { location, json }) {
   if (unsetKeys.length > 0) {
     const badge = bgGreen(black(` Default Preferences `));
     const table = formatTable(flatUnset, ["Preference", "Value"]);
-    console.log(["", badge, table].join("\n"));
+    logger.info("SKIP_FORMAT", ["", badge, table].join("\n"));
   } else {
     const badge = bgGreen(black(` Default Preferences `));
     const message = dim("All preferences have been set");
-    console.log(["", badge, "", message].join("\n"));
+    logger.info("SKIP_FORMAT", ["", badge, "", message].join("\n"));
   }
   if (fromAstroConfig.devToolbar?.enabled === false && flatUser["devToolbar.enabled"]?.value !== false) {
-    console.log(
+    logger.info(
+      "SKIP_FORMAT",
       yellow(
         "The dev toolbar is currently disabled. To enable it, set devToolbar: {enabled: true} in your astroConfig file."
       )
@@ -230,10 +232,10 @@ async function listPreferences(settings, { location, json }) {
   }
   return 0;
 }
-function prettyPrint(value) {
+function prettyPrint(logger, value) {
   const flattened = flattie(value);
   const table = formatTable(flattened, ["Preference", "Value"]);
-  console.log(table);
+  logger.info("SKIP_FORMAT", table);
 }
 const chars = {
   h: "\u2500",