akanjs 0.0.1 → 2.0.0-beta.1

package/devkit/akanConfig/akanConfig.ts

@@ -0,0 +1,332 @@
+import fs from "node:fs";
+import path from "node:path";
+import { type AkanI18nConfig, resolveAkanI18nConfig } from "akanjs/common";
+import type { AkanImageConfig } from "akanjs/server";
+import type { App, Lib } from "../commandDecorators";
+import { WorkspaceExecutor } from "../executors";
+import type { BaseDevEnv, PackageJson } from "../types";
+import {
+  type AkanMobileConfig,
+  type AkanMobileTargetConfig,
+  type AkanRouteConfig,
+  type AppConfigResult,
+  type Arch,
+  archs,
+  type DatabaseMode,
+  type DeepPartial,
+  type DockerConfig,
+  type LibConfigResult,
+} from "./types";
+
+const DEFAULT_BARREL_IMPORTS = ["akanjs/webkit", "akanjs/common", "akanjs/ui"];
+const DEFAULT_OPTIMIZE_IMPORTS = [
+  "lucide-react",
+  "date-fns",
+  "lodash-es",
+  "ramda",
+  "antd",
+  "react-bootstrap",
+  "ahooks",
+  "@ant-design/icons",
+  "@headlessui/react",
+  "@headlessui-float/react",
+  "@heroicons/react/20/solid",
+  "@heroicons/react/24/solid",
+  "@heroicons/react/24/outline",
+  "@visx/visx",
+  "@tremor/react",
+  "rxjs",
+  "@mui/material",
+  "@mui/icons-material",
+  "recharts",
+  "react-use",
+  "@material-ui/core",
+  "@material-ui/icons",
+  "@tabler/icons-react",
+  "mui-core",
+  "react-icons/*",
+];
+const WORKSPACE_BARREL_FACETS = ["ui", "webkit", "common", "client", "server"] as const;
+const SSR_RUNTIME_PACKAGES = ["react", "react-dom", "react-server-dom-webpack"] as const;
+const NATIVE_RUNTIME_PACKAGES = ["sharp"] as const;
+const DEFAULT_AKAN_IMAGE_CONFIG: AkanImageConfig = {
+  deviceSizes: [640, 750, 828, 1080, 1200, 1920, 2048, 3840],
+  imageSizes: [32, 48, 64, 96, 128, 256, 384],
+  formats: ["image/webp"],
+  qualities: [75],
+  minimumCacheTTL: 14400,
+  remotePatterns: [],
+  localPatterns: [{ pathname: "/**" }],
+  dangerouslyAllowSVG: false,
+  maximumRedirects: 3,
+  fetchTimeoutMs: 7000,
+  maxRemoteBytes: 25 * 1024 * 1024,
+};
+
+export class AkanAppConfig implements AppConfigResult {
+  app: App;
+  rootPackageJson: PackageJson;
+  docker: DockerConfig;
+  defaultDatabaseMode: DatabaseMode;
+  externalLibs: string[];
+  barrelImports: string[];
+  optimizeImports: string[];
+  images: AkanImageConfig;
+  i18n: AkanI18nConfig;
+  publicEnv: string[];
+  mobile: AkanMobileConfig;
+  baseDevEnv: BaseDevEnv;
+  libs: string[];
+  domains = new Set<string>();
+  subRoutes = new Map<string, Set<string>>();
+  basePaths = new Set<string>();
+  branches = new Set<string>(["debug", "develop", "main"]);
+  constructor(
+    app: App,
+    libs: string[],
+    rootPackageJson: PackageJson,
+    config: DeepPartial<AppConfigResult>,
+    baseDevEnv: BaseDevEnv,
+  ) {
+    this.app = app;
+    this.rootPackageJson = rootPackageJson;
+    this.libs = libs;
+    this.baseDevEnv = baseDevEnv;
+    this.#applyRoutes(config?.routes);
+    this.defaultDatabaseMode = config?.defaultDatabaseMode ?? "single";
+    this.externalLibs = config?.externalLibs ?? [];
+    this.barrelImports = [
+      ...DEFAULT_BARREL_IMPORTS,
+      ...WORKSPACE_BARREL_FACETS.map((facet) => `@apps/${app.name}/${facet}`),
+      ...libs.flatMap((lib) => WORKSPACE_BARREL_FACETS.map((facet) => `@libs/${lib}/${facet}`)),
+      ...(config?.barrelImports ?? []),
+    ];
+    this.optimizeImports = [...new Set([...DEFAULT_OPTIMIZE_IMPORTS, ...(config?.optimizeImports ?? [])])];
+    this.images = mergeImageConfig(config?.images as Partial<AkanImageConfig> | undefined);
+    this.i18n = resolveAkanI18nConfig(config?.i18n);
+    process.env.AKAN_PUBLIC_DEFAULT_LOCALE = this.i18n.defaultLocale;
+    process.env.AKAN_PUBLIC_LOCALES = this.i18n.locales.join(",");
+    this.publicEnv = (config?.publicEnv as string[] | undefined) ?? ([] as string[]);
+    this.mobile = this.#resolveMobileConfig(config.mobile);
+    this.docker = this.#makeDockerContent(config?.docker ?? {});
+  }
+  #resolveMobileConfig(mobile: DeepPartial<AkanMobileConfig> | undefined): AkanMobileConfig {
+    const { targets: rawTargets, ...rawMobile } = mobile ?? {};
+    const appName = rawMobile.appName ?? this.app.name;
+    const appId = rawMobile.appId ?? `com.${this.app.name}.app`;
+    const version = rawMobile.version ?? "0.0.1";
+    const buildNum = rawMobile.buildNum ?? 1;
+    const defaultTargetName = this.#defaultMobileTargetName(rawTargets);
+    const targetEntries = Object.entries(
+      rawTargets ?? {
+        [defaultTargetName]: {},
+      },
+    );
+    const targets = Object.fromEntries(
+      targetEntries.map(([name, rawTarget]) => {
+        const target = rawTarget as DeepPartial<AkanMobileTargetConfig>;
+        const fallbackBasePath = !rawTargets && this.basePaths.has(name) ? name : undefined;
+        const basePath = (target.basePath ?? fallbackBasePath)?.replace(/^\/+|\/+$/g, "") || undefined;
+        if (basePath && !this.basePaths.has(basePath)) {
+          throw new Error(
+            `Mobile target '${name}' uses unknown basePath '${basePath}' in apps/${this.app.name}/akan.config.ts`,
+          );
+        }
+        const resolved = {
+          ...rawMobile,
+          ...target,
+          name,
+          basePath,
+          appName: target.appName ?? appName,
+          appId: target.appId ?? appId,
+          version: target.version ?? version,
+          buildNum: target.buildNum ?? buildNum,
+          plugins: {
+            ...rawMobile.plugins,
+            ...target.plugins,
+          },
+          android: {
+            ...rawMobile.android,
+            ...target.android,
+          },
+          ios: {
+            ...rawMobile.ios,
+            ...target.ios,
+          },
+        } satisfies AkanMobileTargetConfig;
+        return [name, resolved];
+      }),
+    );
+    return {
+      ...rawMobile,
+      appName,
+      appId,
+      version,
+      buildNum,
+      targets,
+      plugins: rawMobile.plugins,
+    } as AkanMobileConfig;
+  }
+  #defaultMobileTargetName(rawTargets: DeepPartial<AkanMobileConfig>["targets"] | undefined) {
+    if (rawTargets && Object.keys(rawTargets).length > 0) return Object.keys(rawTargets)[0] as string;
+    return this.basePaths.has(this.app.name) ? this.app.name : "default";
+  }
+  #applyRoutes(routes: AkanRouteConfig[] = []) {
+    for (const route of routes) {
+      if (route.basePath) {
+        const basePath = route.basePath.replace(/^\/+|\/+$/g, "");
+        this.basePaths.add(basePath);
+        const domains = this.subRoutes.getOrInsert(basePath, new Set());
+        Object.keys(route.domains).forEach((branch) => void this.branches.add(branch));
+        Object.values(route.domains)
+          .flat()
+          .forEach((domain) => {
+            if (domain) domains.add(domain.toLowerCase().replace(/:\d+$/, ""));
+          });
+      } else {
+        Object.keys(route.domains).forEach((branch) => void this.branches.add(branch));
+        Object.values(route.domains)
+          .flat()
+          .forEach((domain) => {
+            if (domain) this.domains.add(domain.toLowerCase().replace(/:\d+$/, ""));
+          });
+      }
+    }
+    const appName = this.app.name.toLowerCase();
+    const serveDomain = this.baseDevEnv.serveDomain.toLowerCase();
+    if (this.subRoutes.size === 0)
+      this.branches.forEach((branch) => void this.domains.add(`${appName}-${branch}.${serveDomain}`));
+    else
+      Array.from(this.subRoutes.entries()).forEach(([basePath, domains]) => {
+        this.branches.forEach((domain) => void domains.add(`${basePath}-${domain}.${serveDomain}`));
+      });
+  }
+  #getDockerRunScripts(runs: (string | { [key in Arch]?: string })[]) {
+    return runs.map((run) => {
+      if (typeof run === "string") return `RUN ${run}`;
+      else
+        return Object.entries(run)
+          .map(
+            ([arch, script]) => `RUN if [ "$TARGETARCH" = "${arch}" ]; then \
+    ${script}; \
+  fi`,
+          )
+          .join("\n");
+    });
+  }
+  #getDockerImageScript(image: string | { [key in Arch]?: string }, defaultImage: string) {
+    if (typeof image === "string") return `FROM ${image}`;
+    else return archs.map((arch) => `FROM ${image[arch] ?? defaultImage} AS ${arch}`).join("\n");
+  }
+  #makeDockerContent(docker: DeepPartial<DockerConfig>): DockerConfig {
+    if (docker.content) return { content: docker.content, image: {}, preRuns: [], postRuns: [], command: [] };
+    const preRunScripts = this.#getDockerRunScripts(docker.preRuns ?? []);
+    const postRunScripts = this.#getDockerRunScripts(docker.postRuns ?? []);
+
+    const imageScript = docker.image
+      ? this.#getDockerImageScript(docker.image, "oven/bun:1-slim")
+      : "FROM oven/bun:1-slim";
+    const command = docker.command ?? ["bun", "main.js"];
+    const content = `${imageScript}
+RUN ln -sf /usr/share/zoneinfo/Asia/Seoul /etc/localtime
+RUN apt-get update && apt-get upgrade -y
+RUN apt-get install -y --no-install-recommends git redis build-essential python3 ca-certificates fonts-liberation libappindicator3-1 libasound2 libatk-bridge2.0-0 libatk1.0-0 libc6 libcairo2 libcups2 libdbus-1-3 libexpat1 libfontconfig1 libgbm1 libgcc1 libglib2.0-0 libgtk-3-0 libnspr4 libnss3 libpango-1.0-0 libpangocairo-1.0-0 libstdc++6 libx11-6 libx11-xcb1 libxcb1 libxcomposite1 libxcursor1 libxdamage1 libxext6 libxfixes3 libxi6 libxrandr2 libxrender1 libxss1 libxtst6 lsb-release wget xdg-utils udev ffmpeg
+ARG TARGETARCH
+${preRunScripts.join("\n")}
+RUN mkdir -p /workspace
+WORKDIR /workspace
+COPY ./package.json ./package.json
+RUN bun install --production
+${postRunScripts.join("\n")}
+COPY . .
+ENV PORT=8282
+ENV NODE_ENV=production
+ENV AKAN_PUBLIC_REPO_NAME=${this.baseDevEnv.repoName}
+ENV AKAN_PUBLIC_SERVE_DOMAIN=${this.baseDevEnv.serveDomain}
+ENV AKAN_PUBLIC_APP_NAME=${this.app.name}
+ENV AKAN_PUBLIC_ENV=${this.baseDevEnv.env}
+${this.basePaths.size ? `ENV AKAN_PUBLIC_BASE_PATHS=${[...this.basePaths].join(",")}` : ""}
+ENV AKAN_PUBLIC_DEFAULT_LOCALE=${this.i18n.defaultLocale}
+ENV AKAN_PUBLIC_LOCALES=${this.i18n.locales.join(",")}
+ENV AKAN_PUBLIC_OPERATION_MODE=cloud
+
+CMD [${command.map((c) => `"${c}"`).join(",")}]`;
+    return { content, image: imageScript, preRuns: docker.preRuns ?? [], postRuns: docker.postRuns ?? [], command };
+  }
+  static async from(app: App) {
+    const [configImp, baseDevEnv, libs, rootPackageJson] = await Promise.all([
+      import(`${app.cwdPath}/akan.config.ts`).then((mod) => mod.default),
+      WorkspaceExecutor.getBaseDevEnv(path.join(app.workspace.workspaceRoot, ".env")),
+      app.workspace.getLibs(),
+      app.workspace.getPackageJson(),
+    ]);
+    const config = typeof configImp === "function" ? configImp(app) : configImp;
+    return new AkanAppConfig(app, libs, rootPackageJson, config, baseDevEnv);
+  }
+  getProductionPackageJson(data: Partial<PackageJson> = {}): PackageJson {
+    return {
+      name: this.app.name,
+      description: this.app.name,
+      version: "1.0.0",
+      main: "./main.js",
+      dependencies: Object.fromEntries(
+        [...new Set([...this.externalLibs, ...SSR_RUNTIME_PACKAGES, ...NATIVE_RUNTIME_PACKAGES])].map((lib) => {
+          const version = this.rootPackageJson.dependencies?.[lib] ?? this.rootPackageJson.devDependencies?.[lib];
+          if (!version) throw new Error(`Dependency ${lib} not found in package.json`);
+          return [lib, version];
+        }),
+      ),
+      ...data,
+    };
+  }
+}
+
+function mergeImageConfig(config: Partial<AkanImageConfig> = {}): AkanImageConfig {
+  return {
+    ...DEFAULT_AKAN_IMAGE_CONFIG,
+    ...config,
+    deviceSizes: config.deviceSizes ?? DEFAULT_AKAN_IMAGE_CONFIG.deviceSizes,
+    imageSizes: config.imageSizes ?? DEFAULT_AKAN_IMAGE_CONFIG.imageSizes,
+    formats: config.formats ?? DEFAULT_AKAN_IMAGE_CONFIG.formats,
+    qualities: config.qualities ?? DEFAULT_AKAN_IMAGE_CONFIG.qualities,
+    remotePatterns: config.remotePatterns ?? DEFAULT_AKAN_IMAGE_CONFIG.remotePatterns,
+    localPatterns: config.localPatterns ?? DEFAULT_AKAN_IMAGE_CONFIG.localPatterns,
+  };
+}
+
+export class AkanLibConfig implements LibConfigResult {
+  lib: Lib;
+  externalLibs: string[];
+  constructor(lib: Lib, config: DeepPartial<LibConfigResult>) {
+    this.lib = lib;
+    this.externalLibs = config?.externalLibs ?? [];
+  }
+  static async from(lib: Lib) {
+    const [configImp] = await Promise.all([import(`${lib.cwdPath}/akan.config.ts`).then((mod) => mod.default)]);
+    const config = typeof configImp === "function" ? configImp(lib) : configImp;
+    return new AkanLibConfig(lib, config);
+  }
+}
+
+export const increaseBuildNum = async (app: App) => {
+  const appConfig = await AkanAppConfig.from(app);
+  const akanConfigPath = path.join(app.cwdPath, "akan.config.ts");
+  const akanConfig = fs.readFileSync(akanConfigPath, "utf8");
+  const akanConfigContent = akanConfig.replace(
+    `buildNum: ${appConfig.mobile.buildNum}`,
+    `buildNum: ${appConfig.mobile.buildNum + 1}`,
+  );
+  
+  fs.writeFileSync(akanConfigPath, akanConfigContent);
+};
+
+export const decreaseBuildNum = async (app: App) => {
+  const appConfig = await AkanAppConfig.from(app);
+  const akanConfigPath = path.join(app.cwdPath, "akan.config.ts");
+  const akanConfig = fs.readFileSync(akanConfigPath, "utf8");
+  const akanConfigContent = akanConfig.replace(
+    `buildNum: ${appConfig.mobile.buildNum}`,
+    `buildNum: ${appConfig.mobile.buildNum - 1}`,
+  );
+  fs.writeFileSync(akanConfigPath, akanConfigContent);
+};

package/devkit/akanConfig/index.ts

@@ -0,0 +1,2 @@
+export * from "./akanConfig";
+export * from "./types";

package/devkit/akanConfig/types.ts

@@ -0,0 +1,187 @@
+import type { CapacitorConfig } from "@capacitor/cli";
+import type { AkanI18nConfig } from "akanjs/common";
+import type { AkanImageConfig } from "akanjs/server";
+import type { App, Lib } from "../commandDecorators";
+
+export const archs = ["amd64", "arm64"] as const;
+/** CPU architecture names supported by architecture-specific Docker settings. */
+export type Arch = (typeof archs)[number];
+export interface DockerConfig {
+  /** Full Dockerfile content. When set, Akan uses it instead of composing the default Dockerfile. */
+  content: string;
+  /** Base Docker image, either shared for all architectures or mapped by target architecture. */
+  image: string | { [key in Arch]?: string };
+  /** Shell commands inserted before app files are copied into the generated Dockerfile. */
+  preRuns: (string | { [key in Arch]?: string })[];
+  /** Shell commands inserted after production dependencies are installed in the generated Dockerfile. */
+  postRuns: (string | { [key in Arch]?: string })[];
+  /** Container startup command written to the generated Dockerfile CMD instruction. */
+  command: string[];
+}
+
+export interface AkanRouteDomains {
+  /** Production branch domains. */
+  main?: string[];
+  /** Develop branch domains. */
+  develop?: string[];
+  /** Debug branch domains. */
+  debug?: string[];
+  /** Additional branch-specific domains keyed by branch name. */
+  [branch: string]: string[] | undefined;
+}
+
+export interface AkanRouteConfig {
+  /** Optional URL base path served by this route, such as "shop" for /shop. */
+  basePath?: string;
+  /** Domains grouped by branch name for this route. */
+  domains: AkanRouteDomains;
+}
+
+/** Default database topology used by database-aware commands and runtime setup. */
+export type DatabaseMode = "single" | "multiple" | "cluster";
+/** Environment names used when producing mobile builds. */
+export type MobileEnv = "local" | "debug" | "develop" | "main";
+/** Native device permissions that can be requested by a mobile target. */
+export type MobilePermission = "camera" | "contacts" | "location" | "push";
+
+export interface AkanMobileTargetAssets {
+  /** Path to the icon asset used for this native target. */
+  icon?: string;
+  /** Path to the splash screen asset used for this native target. */
+  splash?: string;
+}
+
+export interface AkanMobileTargetLinks {
+  /** Custom URL schemes handled by this native target. */
+  schemes?: string[];
+  /** iOS associated domains used for universal links. */
+  associatedDomains?: string[];
+  /** Android hosts used for app links. */
+  androidHosts?: string[];
+}
+
+export interface AkanMobileTargetFiles {
+  /** Extra iOS files copied into the native project, keyed by destination path. */
+  ios?: Record<string, string>;
+  /** Extra Android files copied into the native project, keyed by destination path. */
+  android?: Record<string, string>;
+}
+
+export interface AkanMobileTargetConfig extends CapacitorConfig {
+  /** Target name used by Akan mobile commands. */
+  name: string;
+  /** Route base path this native target should open. Must match a configured route basePath when set. */
+  basePath?: string;
+  /** Display name for this native target. */
+  appName: string;
+  /** Native application identifier, such as com.example.app. */
+  appId: string;
+  /** Native app version string. */
+  version: string;
+  /** Native build number. */
+  buildNum: number;
+  /** Icon and splash assets for this target. */
+  assets?: AkanMobileTargetAssets;
+  /** Device permissions requested by this target. */
+  permissions?: MobilePermission[];
+  /** Deep link and universal/app link settings for this target. */
+  links?: AkanMobileTargetLinks;
+  /** Extra files copied into native platform projects for this target. */
+  files?: AkanMobileTargetFiles;
+}
+
+export interface AkanMobileConfig extends CapacitorConfig {
+  /** Default display name used by mobile targets. */
+  appName: string;
+  /** Default native application identifier used by mobile targets. */
+  appId: string;
+  /** Default native app version used by mobile targets. */
+  version: string;
+  /** Default native build number used by mobile targets. */
+  buildNum: number;
+  /** Named native build targets, usually mapped to route base paths or app variants. */
+  targets: Record<string, AkanMobileTargetConfig>;
+}
+
+export interface AppConfigResult {
+  /** Customizes the production Dockerfile content, base image, run scripts, and startup command. */
+  docker: DockerConfig;
+  /** Selects the default database deployment mode used by database-aware commands and runtime setup. */
+  defaultDatabaseMode: DatabaseMode;
+  /** Maps app domains and optional base paths for multi-domain or multi-client routing. */
+  routes?: AkanRouteConfig[];
+  /** Lists runtime dependencies that should be preserved in the generated production package. */
+  externalLibs: string[];
+  /** Adds custom barrel import roots to Akan's default framework, app, and library facets. */
+  barrelImports: string[];
+  /** Adds packages or import roots that should participate in optimized import handling. */
+  optimizeImports: string[];
+  /** Configures optimized image sizes, formats, allowed sources, cache, timeout, and byte limits. */
+  images: AkanImageConfig;
+  /** Defines supported locales and the default locale exposed through Akan public locale env values. */
+  i18n: AkanI18nConfig;
+  /** Allows selected environment keys to be exposed to browser-side code. */
+  publicEnv: string[];
+  /** Defines native app identity, versions, targets, permissions, assets, links, and Capacitor options. */
+  mobile: AkanMobileConfig;
+}
+export interface LibConfigResult {
+  /** Lists runtime dependencies that should be preserved when a library requires external packages. */
+  externalLibs: string[];
+}
+
+export type DeepPartial<T> = {
+  [P in keyof T]?: T[P] extends unknown[] ? T[P] : T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+
+export type AppConfig = DeepPartial<AppConfigResult> | ((app: App) => DeepPartial<AppConfigResult>);
+export type LibConfig = DeepPartial<LibConfigResult> | ((lib: Lib) => DeepPartial<LibConfigResult>);
+
+export type AkanConfigFile = object;
+
+export interface FileConventionScanResult {
+  constant: { databases: string[]; scalars: string[] };
+  dictionary: { databases: string[]; services: string[]; scalars: string[] };
+  document: { databases: string[]; scalars: string[] };
+  service: { databases: string[]; services: string[] };
+  signal: { databases: string[]; services: string[] };
+  store: { databases: string[]; services: string[] };
+  template: { databases: string[]; services: string[]; scalars: string[] };
+  unit: { databases: string[]; services: string[]; scalars: string[] };
+  util: { databases: string[]; services: string[]; scalars: string[] };
+  view: { databases: string[]; services: string[]; scalars: string[] };
+  zone: { databases: string[]; services: string[]; scalars: string[] };
+}
+
+export interface ScanResult {
+  name: string;
+  type: "app" | "lib";
+  repoName: string;
+  serveDomain: string;
+  files: FileConventionScanResult;
+  libDeps: string[];
+  pkgDeps: string[];
+  dependencies: string[];
+  devDependencies: string[];
+}
+export interface AppScanResult extends ScanResult {
+  akanConfig: AppConfigResult;
+  routes: string[];
+}
+export interface LibScanResult extends ScanResult {
+  akanConfig: LibConfigResult;
+}
+export interface PkgScanResult {
+  name: string;
+  pkgDeps: string[];
+  dependencies: string[];
+}
+
+export interface WorkspaceScanResult {
+  appNames: string[];
+  libNames: string[];
+  pkgNames: string[];
+  apps: { [key: string]: AppScanResult };
+  libs: { [key: string]: LibScanResult };
+  pkgs: { [key: string]: PkgScanResult };
+}

package/devkit/applicationBuildReporter.ts

@@ -0,0 +1,69 @@
+import { Logger } from "akanjs/common";
+
+export interface ApplicationBuildPhaseResult {
+  id: string;
+  label: string;
+  durationMs: number;
+  summary?: string;
+  skipped?: boolean;
+}
+
+export interface ApplicationBuildResult {
+  phases: ApplicationBuildPhaseResult[];
+  durationMs: number;
+  outputDir: string;
+  artifactDir: string;
+}
+
+export interface ApplicationBuildProgressReporter {
+  phaseStart?(phase: Pick<ApplicationBuildPhaseResult, "id" | "label">): void;
+  phaseDone?(phase: ApplicationBuildPhaseResult): void;
+  phaseFail?(phase: Pick<ApplicationBuildPhaseResult, "id" | "label">, error: unknown): void;
+}
+
+export class ApplicationBuildReporter {
+  static create(): ApplicationBuildProgressReporter {
+    return {
+      phaseDone: (phase) => Logger.rawLog(ApplicationBuildReporter.formatPhaseLine(phase)),
+    };
+  }
+
+  static printSummary(result: ApplicationBuildResult) {
+    Logger.rawLog("");
+    Logger.rawLog(`Route artifacts: ${result.artifactDir}`);
+    Logger.rawLog(`Server output: ${result.outputDir}`);
+    Logger.rawLog(`Done in ${ApplicationBuildReporter.formatDuration(result.durationMs)}`);
+  }
+
+  static formatError(error: unknown): string {
+    if (error instanceof AggregateError) {
+      const nestedMessages = error.errors
+        .map(
+          (nestedError, index) =>
+            ApplicationBuildReporter.formatError(nestedError).trim() || `Unknown error ${index + 1}`,
+        )
+        .map((message) => message.replace(/^/gm, "  "))
+        .join("\n");
+
+      return nestedMessages ? `${error.message}\n${nestedMessages}` : error.message;
+    }
+    if (error instanceof Error) {
+      const causeMessage = error.cause ? `\nCaused by: ${ApplicationBuildReporter.formatError(error.cause)}` : "";
+      return `${error.message}${causeMessage}`;
+    }
+    if (typeof error === "object" && error !== null && "message" in error) return String(error.message);
+    return String(error);
+  }
+
+  static formatDuration(ms: number): string {
+    if (ms < 1000) return `${ms}ms`;
+    if (ms < 60_000) return `${Math.round(ms / 100) / 10}s`;
+    const seconds = Math.floor(ms / 1000);
+    return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  }
+
+  static formatPhaseLine(phase: ApplicationBuildPhaseResult): string {
+    const summary = phase.summary ? `: ${phase.summary}` : "";
+    return `✓ ${phase.label}${summary} (${ApplicationBuildReporter.formatDuration(phase.durationMs)})`;
+  }
+}