astro 7.0.0-alpha.1 → 7.0.0-beta.3

package/dist/assets/utils/inferSourceFormat.js

@@ -1,21 +1,32 @@
 import { removeQueryString } from "@astrojs/internal-helpers/path";
+import { DEFAULT_OUTPUT_FORMAT } from "../consts.js";
 const DATA_PREFIX = "data:";
 function inferSourceFormat(src) {
   if (src.startsWith(DATA_PREFIX)) {
-    const mime = src.slice(DATA_PREFIX.length, src.indexOf(";"));
+    const sepIndex = src.indexOf(";");
+    const commaIndex = src.indexOf(",");
+    const mimeEnd = sepIndex === -1 ? commaIndex : commaIndex === -1 ? sepIndex : Math.min(sepIndex, commaIndex);
+    if (mimeEnd === -1) return void 0;
+    const mime = src.slice(DATA_PREFIX.length, mimeEnd);
     if (mime === "image/svg+xml") return "svg";
     const sub = mime.split("/")[1];
     return sub || void 0;
   }
   try {
     const cleanSrc = removeQueryString(src).split("#")[0];
-    const lastDot = cleanSrc.lastIndexOf(".");
+    const lastSlash = cleanSrc.lastIndexOf("/");
+    const basename = lastSlash === -1 ? cleanSrc : cleanSrc.slice(lastSlash + 1);
+    const lastDot = basename.lastIndexOf(".");
     if (lastDot === -1) return void 0;
-    return cleanSrc.slice(lastDot + 1).toLowerCase();
+    return basename.slice(lastDot + 1).toLowerCase();
   } catch {
     return void 0;
   }
 }
+function resolveDefaultOutputFormat(sourceFormat) {
+  return sourceFormat === "svg" ? "svg" : DEFAULT_OUTPUT_FORMAT;
+}
 export {
-  inferSourceFormat
+  inferSourceFormat,
+  resolveDefaultOutputFormat
 };

package/dist/assets/utils/metadata.js

@@ -10,7 +10,7 @@ async function imageMetadata(data, src) {
       message: AstroErrorData.NoImageMetadata.message(src)
     });
   }
-  if (!result.height || !result.width || !result.type) {
+  if (result.height == null || result.width == null || !result.type) {
     throw new AstroError({
       ...AstroErrorData.NoImageMetadata,
       message: AstroErrorData.NoImageMetadata.message(src)

package/dist/assets/utils/vendor/image-size/types/svg.js

@@ -77,7 +77,7 @@ const SVG = {
     const root = extractorRegExps.root.exec(toUTF8String(input));
     if (root) {
       const attrs = parseAttributes(root[0]);
-      if (attrs.width && attrs.height) {
+      if (attrs.width != null && attrs.height != null) {
         return calculateByDimensions(attrs);
       }
       if (attrs.viewbox) {

package/dist/cli/add/index.js

@@ -46,20 +46,6 @@ export default {
 `,
   LIT_NPMRC: `# Lit libraries are required to be hoisted due to dependency issues.
 public-hoist-pattern[]=*lit*
-`,
-  DB_CONFIG: `import { defineDb } from 'astro:db';
-
-// https://astro.build/db/config
-export default defineDb({
-  tables: {}
-});
-`,
-  DB_SEED: `import { db } from 'astro:db';
-
-// https://astro.build/db/seed
-export default async function seed() {
-	// TODO
-}
 `,
   CLOUDFLARE_WRANGLER_CONFIG: (name, compatibilityDate) => `{
 	"compatibility_date": ${JSON.stringify(compatibilityDate)},
@@ -113,7 +99,6 @@ async function add(names, { flags }) {
           ["node", "astro add node"]
         ],
         Others: [
-          ["db", "astro add db"],
           ["tailwind", "astro add tailwind"],
           ["mdx", "astro add mdx"],
           ["markdoc", "astro add markdoc"],
@@ -235,35 +220,6 @@ async function add(names, { flags }) {
           defaultConfigContent: STUBS.SVELTE_CONFIG
         });
       }
-      if (integrations.find((integration) => integration.id === "db")) {
-        if (!existsSync(new URL("./db/", root))) {
-          logger.info(
-            "SKIP_FORMAT",
-            `
-  ${magenta(
-              `Astro will scaffold ${green("./db/config.ts")}${magenta(" and ")}${green(
-                "./db/seed.ts"
-              )}${magenta(" files.")}`
-            )}
-`
-          );
-          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" }),
-              fs.writeFile(new URL("./db/seed.ts", root), STUBS.DB_SEED, { encoding: "utf-8" })
-            ]);
-          } else {
-            logger.info(
-              "SKIP_FORMAT",
-              `
-  Astro DB requires additional configuration. Please refer to https://astro.build/db/config`
-            );
-          }
-        } else {
-          logger.debug("add", `Using existing db configuration`);
-        }
-      }
       if (integrations.find((integration) => integration.id === "lit") && (await detect({ cwd: fileURLToPath(root) }))?.name === "pnpm") {
         await setupIntegrationConfig({
           root,

package/dist/cli/dev/background.d.ts

@@ -0,0 +1,16 @@
+import type { AstroLogger } from '../../core/logger/core.js';
+import type { Flags } from '../flags.js';
+export interface BackgroundResult {
+    pid: number;
+    url: string;
+    existing?: boolean;
+}
+export interface BackgroundErrorResult {
+    error: string;
+    message: string;
+}
+export declare function formatBackgroundOutput(result: BackgroundResult | BackgroundErrorResult): string;
+export declare function background({ flags, logger, }: {
+    flags: Flags;
+    logger: AstroLogger;
+}): Promise<void>;

package/dist/cli/dev/background.js

@@ -0,0 +1,116 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, openSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import {
+  checkExistingServer,
+  getLogFileURL,
+  readLockFile,
+  removeLockFile,
+  isProcessAlive,
+  GRACEFUL_SHUTDOWN_TIMEOUT
+} from "../../core/dev/lockfile.js";
+import { resolveRoot } from "../../core/config/config.js";
+function formatBackgroundOutput(result) {
+  return JSON.stringify(result);
+}
+async function background({
+  flags,
+  logger
+}) {
+  const root = pathToFileURL(resolveRoot(flags.root) + "/");
+  const existing = checkExistingServer(root);
+  if (existing && !flags.force) {
+    logger.info(
+      "SKIP_FORMAT",
+      `Dev server already running at ${existing.url} (pid ${existing.pid})
+  Stop:   astro dev stop
+  Status: astro dev status
+  Logs:   astro dev logs`
+    );
+    return;
+  }
+  if (existing && flags.force) {
+    try {
+      process.kill(existing.pid, "SIGTERM");
+    } catch {
+    }
+    const deadline2 = Date.now() + GRACEFUL_SHUTDOWN_TIMEOUT;
+    while (Date.now() < deadline2) {
+      if (!isProcessAlive(existing.pid)) break;
+      await new Promise((r) => setTimeout(r, 100));
+    }
+    if (isProcessAlive(existing.pid)) {
+      try {
+        process.kill(existing.pid, "SIGKILL");
+      } catch {
+      }
+    }
+    removeLockFile(root);
+  }
+  const args = ["dev"];
+  if (flags.port) args.push("--port", String(flags.port));
+  if (flags.host != null) {
+    if (typeof flags.host === "string") {
+      args.push("--host", flags.host);
+    } else {
+      args.push("--host");
+    }
+  }
+  if (flags.config) args.push("--config", String(flags.config));
+  if (flags.root) args.push("--root", String(flags.root));
+  if (flags.allowedHosts) args.push("--allowed-hosts", String(flags.allowedHosts));
+  if (flags.json) args.push("--json");
+  const logFileURL = getLogFileURL(root);
+  const logFilePath = fileURLToPath(logFileURL);
+  const dotAstroDir = fileURLToPath(new URL(".astro/", root));
+  if (!existsSync(dotAstroDir)) {
+    mkdirSync(dotAstroDir, { recursive: true });
+  }
+  const logFd = openSync(logFilePath, "w");
+  const rootPath = fileURLToPath(root);
+  const astroBin = resolve(rootPath, "node_modules", ".bin", "astro");
+  const child = spawn(astroBin, args, {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    cwd: rootPath,
+    env: { ...process.env, ASTRO_DEV_BACKGROUND: "1" }
+  });
+  child.unref();
+  const childPid = child.pid;
+  if (!childPid) {
+    logger.error("SKIP_FORMAT", "Failed to spawn background dev server process.");
+    process.exit(1);
+  }
+  const timeout = 3e4;
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(childPid)) {
+      logger.error("SKIP_FORMAT", "Dev server process exited before becoming ready.");
+      process.exit(1);
+    }
+    const lockData = readLockFile(root);
+    if (lockData && lockData.pid === childPid) {
+      logger.info(
+        "SKIP_FORMAT",
+        `Dev server running at ${lockData.url} (pid ${lockData.pid})
+  Stop:   astro dev stop
+  Status: astro dev status
+  Logs:   astro dev logs`
+      );
+      return;
+    }
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  try {
+    process.kill(childPid, "SIGTERM");
+  } catch {
+  }
+  removeLockFile(root);
+  logger.error("SKIP_FORMAT", `Dev server failed to start within ${timeout / 1e3}s.`);
+  process.exit(1);
+}
+export {
+  background,
+  formatBackgroundOutput
+};

package/dist/cli/dev/index.js

@@ -1,14 +1,31 @@
+import { isAgent } from "am-i-vibing";
 import colors from "piccolore";
 import devServer from "../../core/dev/index.js";
+import { pathToFileURL } from "node:url";
+import { checkExistingServer, removeLockFile, writeLockFile } from "../../core/dev/lockfile.js";
+import { resolveRoot } from "../../core/config/config.js";
 import { printHelp } from "../../core/messages/runtime.js";
-import { flagsToAstroInlineConfig } from "../flags.js";
+import { createLoggerFromFlags, flagsToAstroInlineConfig } from "../flags.js";
+function isRunByAgent() {
+  try {
+    return isAgent();
+  } catch {
+    return false;
+  }
+}
 async function dev({ flags }) {
   if (flags.help || flags.h) {
     printHelp({
       commandName: "astro dev",
-      usage: "[...flags]",
+      usage: "[command] [...flags]",
       tables: {
+        Commands: [
+          ["stop", "Stop a running background dev server."],
+          ["status", "Check if a dev server is running."],
+          ["logs [--follow]", "View logs from a background dev server."]
+        ],
         Flags: [
+          ["--background", "Start the dev server as a background process."],
           ["--mode", `Specify the mode of the project. Defaults to "development".`],
           ["--port", `Specify which port to run on. Defaults to 4321.`],
           ["--host", `Listen on all addresses, including LAN and public addresses.`],
@@ -28,8 +45,70 @@ async function dev({ flags }) {
     });
     return;
   }
+  const agentDetected = !process.env.ASTRO_DEV_BACKGROUND && isRunByAgent();
+  if (agentDetected) {
+    flags.json = true;
+  }
+  const logger = createLoggerFromFlags(flags);
+  const subcommand = flags._[3]?.toString();
+  if (subcommand === "stop") {
+    const { stop } = await import("./stop.js");
+    await stop({ flags, logger });
+    return;
+  }
+  if (subcommand === "status") {
+    const { status } = await import("./status.js");
+    await status({ flags, logger });
+    return;
+  }
+  if (subcommand === "logs") {
+    const { logs } = await import("./logs.js");
+    await logs({ flags, logger });
+    return;
+  }
+  if (flags.background || agentDetected) {
+    const { background } = await import("./background.js");
+    await background({ flags, logger });
+    return;
+  }
+  if (subcommand) {
+    logger.error(
+      "SKIP_FORMAT",
+      `Unknown command: astro dev ${subcommand}
+
+Run \`astro dev --help\` to see available commands.`
+    );
+    process.exit(1);
+  }
+  const root = pathToFileURL(resolveRoot(flags.root) + "/");
+  const existingServer = checkExistingServer(root);
+  if (existingServer) {
+    const message = [
+      "Another astro dev server is already running.",
+      "",
+      `  URL:  ${existingServer.url}`,
+      `  PID:  ${existingServer.pid}`,
+      "",
+      `Run \`astro dev stop\` to stop it, or use \`astro dev --force\` to replace it.`
+    ].join("\n");
+    throw new Error(message);
+  }
   const inlineConfig = flagsToAstroInlineConfig(flags);
-  return await devServer(inlineConfig);
+  const server = await devServer(inlineConfig);
+  const serverUrl = new URL(server.resolvedUrls.local[0]).origin;
+  writeLockFile(root, {
+    pid: process.pid,
+    port: server.address.port,
+    url: serverUrl,
+    background: !!process.env.ASTRO_DEV_BACKGROUND,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const originalStop = server.stop.bind(server);
+  server.stop = async () => {
+    removeLockFile(root);
+    await originalStop();
+  };
+  return server;
 }
 export {
   dev

package/dist/cli/dev/logs.d.ts

@@ -0,0 +1,6 @@
+import type { AstroLogger } from '../../core/logger/core.js';
+import type { Flags } from '../flags.js';
+export declare function logs({ flags, logger, }: {
+    flags: Flags;
+    logger: AstroLogger;
+}): Promise<void>;

package/dist/cli/dev/logs.js

@@ -0,0 +1,72 @@
+import { readFileSync, existsSync, statSync, createReadStream, watch } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { checkExistingServer, getLogFileURL, isProcessAlive } from "../../core/dev/lockfile.js";
+import { resolveRoot } from "../../core/config/config.js";
+async function logs({
+  flags,
+  logger
+}) {
+  const root = pathToFileURL(resolveRoot(flags.root) + "/");
+  const existing = checkExistingServer(root);
+  if (!existing) {
+    logger.error("SKIP_FORMAT", "No dev server is running.");
+    process.exit(1);
+  }
+  if (!existing.background) {
+    logger.error(
+      "SKIP_FORMAT",
+      "The running dev server was not started with `astro dev --background`. View logs in the terminal where it was started."
+    );
+    process.exit(1);
+  }
+  const logFileURL = getLogFileURL(root);
+  const logFilePath = fileURLToPath(logFileURL);
+  if (!existsSync(logFilePath)) {
+    logger.error("SKIP_FORMAT", "No log file found.");
+    process.exit(1);
+  }
+  const follow = flags.follow || flags.f;
+  if (!follow) {
+    const content = readFileSync(logFilePath, "utf-8");
+    process.stdout.write(content);
+    return;
+  }
+  let offset = statSync(logFilePath).size;
+  if (offset > 0) {
+    const content = readFileSync(logFilePath, "utf-8");
+    process.stdout.write(content);
+  }
+  const watcher = watch(logFilePath, () => {
+    const currentSize = statSync(logFilePath).size;
+    if (currentSize > offset) {
+      const stream = createReadStream(logFilePath, { start: offset, encoding: "utf-8" });
+      stream.on("data", (chunk) => process.stdout.write(chunk));
+      stream.on("end", () => {
+        offset = currentSize;
+      });
+    }
+  });
+  const aliveCheck = setInterval(() => {
+    if (!isProcessAlive(existing.pid)) {
+      const currentSize = statSync(logFilePath).size;
+      if (currentSize > offset) {
+        const remaining = readFileSync(logFilePath, { encoding: "utf-8" }).slice(offset);
+        process.stdout.write(remaining);
+      }
+      watcher.close();
+      clearInterval(aliveCheck);
+    }
+  }, 1e3);
+  const cleanup = () => {
+    watcher.close();
+    clearInterval(aliveCheck);
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  await new Promise(() => {
+  });
+}
+export {
+  logs
+};

package/dist/cli/dev/status.d.ts

@@ -0,0 +1,15 @@
+import type { AstroLogger } from '../../core/logger/core.js';
+import type { Flags } from '../flags.js';
+export interface StatusResult {
+    running: boolean;
+    pid?: number;
+    url?: string;
+    port?: number;
+    background?: boolean;
+    uptime?: number;
+}
+export declare function formatStatusOutput(result: StatusResult): string;
+export declare function status({ flags, logger, }: {
+    flags: Flags;
+    logger: AstroLogger;
+}): Promise<void>;

package/dist/cli/dev/status.js

@@ -0,0 +1,27 @@
+import { pathToFileURL } from "node:url";
+import { checkExistingServer } from "../../core/dev/lockfile.js";
+import { resolveRoot } from "../../core/config/config.js";
+function formatStatusOutput(result) {
+  return JSON.stringify(result);
+}
+async function status({
+  flags,
+  logger
+}) {
+  const root = pathToFileURL(resolveRoot(flags.root) + "/");
+  const existing = checkExistingServer(root);
+  if (!existing) {
+    logger.info("SKIP_FORMAT", "No dev server is running.");
+    return;
+  }
+  const startedAt = new Date(existing.startedAt).getTime();
+  const uptime = Math.floor((Date.now() - startedAt) / 1e3);
+  logger.info(
+    "SKIP_FORMAT",
+    `Dev server running at ${existing.url} (pid ${existing.pid}, uptime ${uptime}s${existing.background ? ", background" : ""})`
+  );
+}
+export {
+  formatStatusOutput,
+  status
+};

package/dist/cli/dev/stop.d.ts

@@ -0,0 +1,12 @@
+import type { AstroLogger } from '../../core/logger/core.js';
+import type { Flags } from '../flags.js';
+export interface StopResult {
+    stopped: boolean;
+    pid?: number;
+    reason?: string;
+}
+export declare function formatStopOutput(result: StopResult): string;
+export declare function stop({ flags, logger, }: {
+    flags: Flags;
+    logger: AstroLogger;
+}): Promise<void>;

package/dist/cli/dev/stop.js

@@ -0,0 +1,43 @@
+import { pathToFileURL } from "node:url";
+import {
+  checkExistingServer,
+  removeLockFile,
+  isProcessAlive,
+  GRACEFUL_SHUTDOWN_TIMEOUT
+} from "../../core/dev/lockfile.js";
+import { resolveRoot } from "../../core/config/config.js";
+function formatStopOutput(result) {
+  return JSON.stringify(result);
+}
+async function stop({
+  flags,
+  logger
+}) {
+  const root = pathToFileURL(resolveRoot(flags.root) + "/");
+  const existing = checkExistingServer(root);
+  if (!existing) {
+    logger.info("SKIP_FORMAT", "No dev server is running.");
+    return;
+  }
+  try {
+    process.kill(existing.pid, "SIGTERM");
+  } catch {
+  }
+  const deadline = Date.now() + GRACEFUL_SHUTDOWN_TIMEOUT;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(existing.pid)) break;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  if (isProcessAlive(existing.pid)) {
+    try {
+      process.kill(existing.pid, "SIGKILL");
+    } catch {
+    }
+  }
+  removeLockFile(root);
+  logger.info("SKIP_FORMAT", `Stopped dev server (pid ${existing.pid}).`);
+}
+export {
+  formatStopOutput,
+  stop
+};

package/dist/cli/flags.js

@@ -19,11 +19,9 @@ function flagsToAstroInlineConfig(flags) {
       allowedHosts: typeof flags.allowedHosts === "string" ? flags.allowedHosts.split(",") : typeof flags.allowedHosts === "boolean" && flags.allowedHosts === true ? flags.allowedHosts : []
     }
   };
-  if (flags.experimentalJson) {
-    inlineConfig.experimental = {
-      logger: {
-        entrypoint: "astro/logger/json"
-      }
+  if (flags.json) {
+    inlineConfig.logger = {
+      entrypoint: "astro/logger/json"
     };
   }
   return inlineConfig;
@@ -35,7 +33,7 @@ function createLoggerFromFlags(flags) {
   } else if (flags.silent) {
     logLevel = "silent";
   }
-  if (flags.experimentalJson) {
+  if (flags.json) {
     return createJsonLoggerFromFlags({ logLevel });
   } else {
     return createNodeLoggerFromFlags({ logLevel });

package/dist/cli/help/index.js

@@ -8,7 +8,6 @@ const DEFAULT_HELP_PAYLOAD = {
       ["build", "Build your project and write it to disk."],
       ["check", "Check your project for errors."],
       ["create-key", "Create a cryptography key"],
-      ["db", "Manage your Astro database."],
       ["dev", "Start the development server."],
       ["docs", "Open documentation in your web browser."],
       ["info", "List info about your current Astro setup."],
@@ -26,7 +25,7 @@ const DEFAULT_HELP_PAYLOAD = {
       ["--silent", "Disable all logging."],
       ["--version", "Show the version number and exit."],
       ["--help", "Show this help message."],
-      ["--experimental-json", "Enables JSON logging."]
+      ["--json", "Enables JSON logging."]
     ]
   }
 };

package/dist/cli/index.js

@@ -13,12 +13,7 @@ function resolveCommand(flags) {
     "check",
     "create-key",
     "docs",
-    "db",
-    "info",
-    "login",
-    "logout",
-    "link",
-    "init"
+    "info"
   ]);
   if (supportedCommands.has(cmd)) {
     return cmd;
@@ -183,15 +178,6 @@ async function runCommand(cmd, flags) {
       await add(packages, { flags });
       return;
     }
-    case "db":
-    case "login":
-    case "logout":
-    case "link":
-    case "init": {
-      const { db } = await import("./db/index.js");
-      await db({ flags });
-      return;
-    }
     case "dev": {
       const { dev } = await import("./dev/index.js");
       const server = await dev({ flags });

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.0.0-alpha.1";
+  version = "7.0.0-beta.3";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/container/index.js

@@ -63,10 +63,7 @@ function createManifest(manifest, renderers, middleware) {
       placement: void 0
     },
     logLevel: "silent",
-    experimentalQueuedRendering: manifest?.experimentalQueuedRendering ?? {
-      enabled: false
-    },
-    experimentalLogger: manifest?.experimentalLogger ?? void 0
+    loggerConfig: manifest?.loggerConfig ?? void 0
   };
 }
 class experimental_AstroContainer {