CLI and Build Commands

/**
 * Builds the Astro project for production
 * @param inlineConfig - Configuration options for the build
 * @param options - Build-specific options
 * @returns Promise that resolves when build completes
 */
function build(inlineConfig: AstroInlineConfig, options?: BuildOptions): Promise<void>;

import { build } from 'astro';

await build({
  root: './my-project',
  mode: 'production',
});

/**
 * Starts the development server
 * @returns Promise that resolves with DevServer instance when server starts
 */
function dev(inlineConfig: AstroInlineConfig): Promise<DevServer>;

interface DevServer {
  address: AddressInfo;
  handle: (req: http.IncomingMessage, res: http.ServerResponse<http.IncomingMessage>) => void;
  watcher: vite.FSWatcher;
  stop(): Promise<void>;
}

import { dev } from 'astro';

const server = await dev({
  root: './my-project',
  server: {
    port: 3000,
    host: true,
  },
});

await server.stop();

/**
 * Previews the production build
 * @returns Promise that resolves with PreviewServer instance when server starts
 */
function preview(inlineConfig: AstroInlineConfig): Promise<PreviewServer>;

import { preview } from 'astro';

await preview({
  root: './my-project',
  server: {
    port: 4321,
  },
});

/**
 * Generates TypeScript types for Astro modules (experimental)
 * @returns Promise that resolves when sync completes
 */
function sync(inlineConfig: AstroInlineConfig): Promise<void>;

import { sync } from 'astro';

await sync({
  root: './my-project',
});

interface BuildOptions {
  /**
   * Output a development-based build
   * @default false
   */
  devOutput?: boolean;

  /**
   * Teardown the compiler WASM instance after build
   * @default true
   */
  teardownCompiler?: boolean;
}

interface PreviewServer {
  host?: string;
  port: number;
  stop(): Promise<void>;
  closed(): Promise<void>;
}

interface AstroInlineConfig {
  /**
   * Project root directory
   * @default process.cwd()
   */
  root?: string | URL;

  /**
   * Build mode
   * @default 'development' for dev, 'production' for build
   */
  mode?: 'development' | 'production';

  server?: {
    port?: number;
    host?: string | boolean;
    open?: boolean | string;
  };

  site?: string;
  base?: string;
  output?: 'static' | 'server';
  trailingSlash?: 'always' | 'never' | 'ignore';
  adapter?: AstroAdapter;
  integrations?: AstroIntegration[];
  vite?: ViteUserConfig;
}

# Development server
astro dev [root]
  --port <number>        Port to run dev server on (default: 4321)
  --host [address]       Network address to listen on
  --open                 Open browser on server start
  --mode <mode>          Build mode (default: development)
  --force                Force rebuild
  --allowed-hosts <hosts> Allowed hosts for CORS

# Production build
astro build [root]
  --outDir <directory>   Output directory (default: dist)
  --mode <mode>          Build mode (default: production)
  --devOutput            Output development-style build
  --force                Force rebuild

# Preview production build
astro preview [root]
  --port <number>        Port to run preview server on (default: 4321)
  --host [address]       Network address to listen on
  --open                 Open browser on server start
  --allowed-hosts <hosts> Allowed hosts for CORS

# Type generation
astro sync [root]
  --force                Force regeneration

# Add integrations
astro add <integration>

# Type checking
astro check

# Show environment info
astro info

# Configure telemetry
astro telemetry [enable|disable|reset]

# Configure preferences
astro preferences list
astro preferences set <key> <value>
astro preferences reset <key>