sitevision-cli 1.0.0-beta.32 → 1.0.0-beta.33

package/dist/utils/project-detection.d.ts

@@ -1,210 +0,0 @@
-import type { SitevisionManifest, DevProperties, ProjectInfo, ProjectPaths, SimpleAppType, ApiEndpoints, LocalizedString } from '../types/index.js';
-export type { SitevisionManifest, DevProperties, ProjectInfo, } from '../types/index.js';
-/**
- * Resolve a manifest text field that may be a plain string or a localized
- * object (e.g. `{sv: 'Namn', en: 'Name'}`) to a single display string.
- *
- * Preference order: Swedish, then English, then any available language. Returns
- * an empty string for missing/empty values. This guards the UI from rendering a
- * raw object as a React child, which Sitevision's localized manifests would
- * otherwise trigger.
- */
-export declare function localizedText(value: LocalizedString | undefined, preferred?: string): string;
-/**
- * Get standard project paths for a given root directory
- */
-export declare function getProjectPaths(root: string, manifestPath: string, devPropertiesPath: string | null): ProjectPaths;
-/**
- * Find the dev properties file path (supports both naming conventions)
- */
-export declare function findDevPropertiesPath(root: string): string | null;
-/**
- * Get the default dev properties path (for creating new files)
- */
-export declare function getDefaultDevPropertiesPath(root: string): string;
-/** A bare host: no scheme, no path, no stray spaces. */
-export declare function normalizeDomain(value: string): string;
-/**
- * The dev properties a workspace root defines (its own file merged over any
- * ancestors'), with the deploy password resolved from the keychain like an
- * app's would be. Used to edit shared config from the shell.
- */
-export declare function readWorkspaceDevProperties(root: string): Partial<DevProperties>;
-/** Ancestor directories' .dev_properties.json merged, nearest wins (no own file). */
-export declare function readAncestorDevProperties(root: string): Partial<DevProperties>;
-/** Shared defaults from package.json: the workspace root's first, the app's on top. */
-export declare function readPackageDefaultsChain(root: string): Partial<DevProperties>;
-/**
- * Everything an app's own .dev_properties.json sits on top of: package.json
- * defaults (root, then app), then ancestor .dev_properties.json files.
- */
-export declare function readInheritedDevProperties(root: string): Partial<DevProperties>;
-/**
- * Get the full app ID including any prefix/suffix from environment
- *
- * This combines: prefix + baseId + suffix
- * Used for generating zip filenames and deployment identifiers
- */
-export declare function getFullAppId(baseId: string): string;
-/**
- * Get the zip filename for an app
- */
-export declare function getZipFilename(manifest: SitevisionManifest): string;
-/**
- * Get the signed zip filename for an app
- */
-export declare function getSignedZipFilename(manifest: SitevisionManifest): string;
-/**
- * Get the full path to the zip file in dist/
- */
-export declare function getZipPath(projectRoot: string, manifest: SitevisionManifest): string;
-/**
- * Get the full path to the signed zip file in dist/
- */
-export declare function getSignedZipPath(projectRoot: string, manifest: SitevisionManifest): string;
-/**
- * The zip a non-production deploy uploads: the signed one when it is at least
- * as new as the build, since some sites reject unsigned apps even on dev.
- */
-export declare function getDeployZipPath(projectRoot: string, manifest: SitevisionManifest): string;
-/**
- * Get API endpoints for the given app type
- */
-export declare function getApiEndpoints(appType: SimpleAppType): ApiEndpoints;
-/**
- * Build the base URL for API requests
- */
-export declare function buildApiBaseUrl(domain: string, siteName: string, useHTTP?: boolean): string;
-/**
- * Build the addon endpoint URL
- */
-export declare function buildAddonEndpointUrl(domain: string, siteName: string, appType: SimpleAppType, useHTTP?: boolean): string;
-/**
- * Build the import endpoint URL
- */
-export declare function buildImportEndpointUrl(domain: string, siteName: string, addonName: string, appType: SimpleAppType, useHTTP?: boolean): string;
-/**
- * Thrown when a manifest.json is present but cannot be parsed. Kept distinct from
- * a plain "no project here" (null) so the CLI can tell the user their manifest is
- * malformed instead of the misleading "Not a Sitevision project".
- */
-export declare class ManifestParseError extends Error {
-    constructor(manifestPath: string, cause: unknown);
-}
-/**
- * Read manifest.json from its supported locations (root, static/, src/).
- * Throws ManifestParseError on malformed JSON.
- */
-export declare function readManifest(cwd: string): {
-    manifestPath: string;
-    manifest: SitevisionManifest;
-} | null;
-/**
- * Set one text field of manifest.json, or one language of a localized field.
- * An empty value removes the key. A value that is already a string is replaced
- * in the text, so comments and formatting survive; anything else rewrites the
- * file, which is refused when that would drop comments.
- */
-export declare function writeManifestField(manifestPath: string, key: string, value: string, lang?: string): void;
-/**
- * Detect if the current directory is a Sitevision project
- */
-export declare function detectProject(cwd?: string): ProjectInfo | null;
-/**
- * Fill the runtime-only credential fields for the given domain/username:
- * deploy password (env var > keychain), OAuth2 access token (env var), and
- * session cookie (env var > keychain). Mutates and returns `dev`.
- */
-export declare function resolveRuntimeSecrets(dev: DevProperties): DevProperties;
-/**
- * Validate that we're in a Sitevision project directory
- */
-export declare function requireProject(cwd?: string): ProjectInfo;
-/**
- * The app type (web, widget, rest, mcp), or undefined for a manifest type
- * this CLI does not know. Display code uses this so one odd app never takes
- * the whole shell down.
- */
-export declare function appTypeOf(manifest: SitevisionManifest): SimpleAppType | undefined;
-/**
- * Get the app type (web, widget, rest, mcp). Throws for unknown types, since
- * build and deploy cannot proceed without knowing the endpoints.
- */
-export declare function getAppType(manifest: SitevisionManifest): SimpleAppType;
-/**
- * Check if the app uses webpack bundling
- */
-export declare function isBundledApp(manifest: SitevisionManifest): boolean;
-/**
- * Read and parse the dev properties file
- */
-export declare function readDevProperties(projectRoot: string): DevProperties | null;
-/**
- * Write dev properties to file. Secrets are never persisted — `password`,
- * `accessToken` and `sessionCookie` are held in the OS keychain / resolved at
- * runtime instead.
- */
-export declare function writeDevProperties(projectRoot: string, properties: DevProperties, { complete }?: {
-    complete?: boolean;
-}): void;
-/**
- * CLI preferences stored in .svcconfig at the project root. Unknown keys are
- * preserved on write so hand-edited entries survive.
- */
-export interface SvcConfig {
-    syncPackageJson?: boolean;
-    environment?: string;
-    [key: string]: unknown;
-}
-export declare function readSvcConfig(projectRoot: string): SvcConfig;
-export declare function writeSvcConfig(projectRoot: string, updates: SvcConfig): void;
-/**
- * Values tied to the person running svc. They stay in .dev_properties.json and
- * never go into package.json.
- */
-export declare const USER_KEYS: string[];
-export interface PackageJsonSyncChange {
-    key: string;
-    from?: string;
-    to: string;
-}
-/** The shared defaults one directory's package.json provides. */
-export declare function readPackageDefaults(dir: string): Partial<DevProperties>;
-/** What an unset field means, so spelling out the default is not a change. */
-export declare const IMPLICIT_VALUES: Record<string, unknown>;
-/** What syncing this directory would change in its package.json. */
-export declare function getPackageJsonSyncChanges(dir: string): PackageJsonSyncChange[];
-export declare function hasPackageJson(dir: string): boolean;
-/**
- * Copy the pending shared values from .dev_properties.json, and the manifest
- * fields package.json mirrors, into package.json, creating package.json when
- * the directory has none. Throws if it cannot be
- * read or written.
- */
-export declare function syncDevPropertiesToPackageJson(dir: string): boolean;
-/**
- * Edit package.json in place, keeping its indentation and trailing newline. A
- * missing file is created; an unreadable or invalid one throws, so the caller
- * can warn instead of dropping the change silently.
- */
-export declare function updatePackageJson(dir: string, mutate: (packageJson: Record<string, unknown>) => void): void;
-/**
- * Move a plaintext password from .dev_properties.json into the OS keychain and
- * strip it from the file. Returns true if the password was migrated.
- *
- * The in-memory `project.devProperties.password` is intentionally left intact
- * so the current invocation can keep using it; only the on-disk copy is removed.
- */
-export declare function migrateLegacyPassword(project: ProjectInfo): boolean;
-/**
- * Ensure the dist directory exists
- */
-export declare function ensureDistDir(projectRoot: string): string;
-/**
- * Ensure the build directory exists
- */
-export declare function ensureBuildDir(projectRoot: string): string;
-/**
- * Clean the build directory
- */
-export declare function cleanBuildDir(projectRoot: string): void;

package/dist/utils/session-cookie-auth.d.ts

@@ -1,35 +0,0 @@
-import type { DevProperties } from '../types/index.js';
-interface RawCookie {
-    name: string;
-    value: string;
-    domain: string;
-}
-export interface CaptureResult {
-    cookie?: string;
-    note?: string;
-    error?: string;
-}
-export interface CookieLoginSession {
-    capture: () => Promise<CaptureResult>;
-    close: () => Promise<void>;
-    loginUrl: string;
-}
-/**
- * Pick the session from a cookie jar: find JSESSIONID (preferring the deploy
- * host), then return every cookie on that host as a `Cookie:` header. On miss,
- * return diagnostics naming the domains actually seen. Pure — no keychain, no
- * browser — so it's unit-testable.
- */
-export declare function selectSessionCookie(all: RawCookie[], siteDomain: string): CaptureResult;
-/**
- * Launch a real browser at the login URL for an interactive SAML/SSO login and
- * return handles to capture the session and close the browser. UI-agnostic: the
- * Ink login screen decides when to `capture()` (on the user's keypress) and
- * `close()`. Returns null if the browser can't be launched.
- *
- * `capture()` reads the whole cookie jar via CDP (httponly and secure included),
- * stores the session in the keychain on success, and otherwise returns
- * diagnostics naming the cookie domains it actually saw.
- */
-export declare function beginCookieLogin(dev: DevProperties): Promise<CookieLoginSession | null>;
-export {};

package/dist/utils/signing-password.d.ts

@@ -1,12 +0,0 @@
-/**
- * Resolve the signing password for the given user.
- *
- * Priority:
- * 1. `SITEVISION_SIGNING_PASSWORD` env var (non-interactive override, no prompts).
- * 2. A password saved in the OS keychain — the user is asked whether to use it
- * or set a new one. Choosing "new" optionally updates the saved password.
- * 3. An interactive prompt — optionally saved to the keychain.
- *
- * Returns an empty string if no password could be obtained.
- */
-export declare function resolveSigningPassword(signingUsername: string): Promise<string>;

package/dist/utils/signing-step.d.ts

@@ -1,15 +0,0 @@
-export type SigningStep = 'proceed' | 'choice' | 'input';
-/**
- * Decide what to do when a signing password is needed.
- *
- * - `proceed`: a password is already available this session — use it.
- * - `choice`: a password is saved in the keychain — ask whether to use it or
- * enter a new one.
- * - `input`: prompt for a password (nothing saved, or a saved one just failed
- * and we're retrying).
- */
-export declare function decideSigningStep(options: {
-    hasSessionPassword: boolean;
-    hasStoredPassword: boolean;
-    isRetry: boolean;
-}): SigningStep;

package/dist/utils/signing-step.js

@@ -1,16 +0,0 @@
-/**
- * Decide what to do when a signing password is needed.
- *
- * - `proceed`: a password is already available this session — use it.
- * - `choice`: a password is saved in the keychain — ask whether to use it or
- * enter a new one.
- * - `input`: prompt for a password (nothing saved, or a saved one just failed
- * and we're retrying).
- */
-export function decideSigningStep(options) {
-    if (options.hasSessionPassword)
-        return 'proceed';
-    if (options.hasStoredPassword && !options.isRetry)
-        return 'choice';
-    return 'input';
-}

package/dist/utils/sitevision-api.d.ts

@@ -1,155 +0,0 @@
-/**
- * Sitevision API Client
- *
- * Handles all API interactions with Sitevision servers:
- * - Signing apps via developer.sitevision.se
- * - Deploying to development environments
- * - Deploying to production environments
- * - Creating addons
- * - Activating production apps
- */
-import type { SigningCredentials, DeployConfig, ProductionDeployConfig, SigningResponse, DeployResponse, CreateAddonResponse, ActivationResponse, SimpleAppType } from '../types/index.js';
-/**
- * Create Basic Auth header value
- */
-declare function createBasicAuth(username: string, password: string): string;
-type RequestAuth = {
-    username: string;
-    password: string;
-} | {
-    token: string;
-} | {
-    cookie: string;
-};
-type AuthKind = 'basic' | 'bearer' | 'cookie';
-/** Single source of the 401 message, worded for the auth kind actually used. */
-declare function unauthorizedMessage(kind: AuthKind): string;
-/** Pick cookie > bearer > basic based on what the deploy config carries. */
-declare function configAuth(config: {
-    username: string;
-    password?: string;
-    accessToken?: string;
-    sessionCookie?: string;
-}): {
-    auth: RequestAuth;
-    kind: AuthKind;
-};
-/**
- * Make an HTTP/HTTPS request
- */
-export declare function makeRequest(url: string, options: {
-    method: string;
-    headers?: Record<string, string>;
-    body?: Buffer;
-    auth?: RequestAuth;
-    timeoutMs?: number;
-}): Promise<{
-    statusCode: number;
-    body: Buffer;
-    headers: Record<string, string>;
-}>;
-/**
- * Whether an HTTP status is worth retrying (transient server-side failures).
- */
-export declare function isRetryableStatus(statusCode: number): boolean;
-/**
- * Summarize a non-success response body for error messages.
- * Avoids dumping raw bytes (e.g. an HTML error page or a binary blob) by
- * trimming text bodies and labelling binary ones by their content type.
- */
-export declare function summarizeErrorBody(body: Buffer, headers: Record<string, string>): string;
-/**
- * Check that a buffer begins with the ZIP magic bytes. Used to fail fast when
- * the signing endpoint returns an error page with HTTP 200.
- */
-export declare function looksLikeZip(body: Buffer): boolean;
-/**
- * A stale Sitevision session usually answers with a redirect to the login page
- * or a 200 carrying an HTML login form — not a clean 401. Detect both so cookie
- * auth can drop the dead session and re-login instead of showing a generic error.
- */
-export declare function looksLikeAuthExpired(statusCode: number, body: Buffer, headers: Record<string, string>): boolean;
-/**
- * Sign an app via developer.sitevision.se
- *
- * @param zipPath - Path to the unsigned zip file
- * @param credentials - Signing credentials
- * @param outputPath - Path to write the signed zip file
- */
-export declare function signApp(zipPath: string, credentials: SigningCredentials, outputPath: string): Promise<SigningResponse>;
-/**
- * Deploy an app to a development environment
- *
- * @param zipPath - Path to the zip file (signed or unsigned)
- * @param config - Deployment configuration
- * @param appType - The app type (web, widget, rest)
- * @param force - Whether to force deploy (overwrite existing)
- */
-export declare function deployApp(zipPath: string, config: DeployConfig, appType: SimpleAppType, force?: boolean): Promise<DeployResponse>;
-/**
- * Deploy an app to production
- *
- * @param signedZipPath - Path to the SIGNED zip file (required for production)
- * @param config - Production deployment configuration
- * @param appType - The app type (web, widget, rest)
- */
-export declare function deployProduction(signedZipPath: string, config: ProductionDeployConfig, appType: SimpleAppType): Promise<DeployResponse>;
-/**
- * Create a new addon on a Sitevision site
- *
- * @param config - Deployment configuration
- * @param appType - The app type (web, widget, rest)
- */
-export declare function createAddon(config: DeployConfig, appType: SimpleAppType): Promise<CreateAddonResponse>;
-/**
- * Activate a deployed production app
- *
- * @param executableId - The executable ID returned from deployment
- * @param config - Deployment configuration
- * @param appType - The app type (web, widget, rest)
- */
-export declare function activateApp(executableId: string, config: DeployConfig, _appType: SimpleAppType): Promise<ActivationResponse>;
-/**
- * A version uploaded to a custom module, as reported by the
- * ActivateCustomModuleExecutable GET endpoint.
- */
-export interface Executable {
-    id: string;
-    name: string;
-    appIdentifier: string;
-    appVersion: string;
-    active: boolean;
-}
-export interface ListExecutablesResponse {
-    success: boolean;
-    executables?: Executable[];
-    error?: string;
-    authExpired?: boolean;
-}
-/**
- * List the executables (uploaded versions) of the configured addon.
- */
-export declare function listExecutables(config: DeployConfig): Promise<ListExecutablesResponse>;
-export interface AddonNode {
-    id: string;
-    name: string;
-    type: string;
-    appType?: SimpleAppType;
-}
-/**
- * List the addons (custom modules) in the site's Addon Repository.
- */
-export declare function listAddons(config: DeployConfig): Promise<{
-    success: boolean;
-    addons?: AddonNode[];
-    error?: string;
-}>;
-/**
- * Whether an addon exists, judged from a listAddons result. A failed or empty
- * listing is "unknown": a dead session can look exactly like an empty site.
- */
-export declare function classifyAddon(listed: {
-    success: boolean;
-    addons?: AddonNode[];
-}, name: string): 'missing' | 'present' | 'unknown';
-export { createBasicAuth, configAuth, unauthorizedMessage };

package/dist/utils/sitevision-scripts-runner.d.ts

@@ -1,84 +0,0 @@
-/**
- * Sitevision Scripts Runner
- *
- * Delegates the compile/build step to the official sitevision-scripts npm
- * package when a project has no local webpack config of its own.
- *
- * Sitevision WebApp builds are tightly coupled to the platform runtime (a
- * dual server/client multi-compiler, AMD externals for React and the sitevision
- * api packages, an embedded ES5 server engine, and a precise addon zip layout).
- * Rather than
- * reproduce that contract — which lives in proprietary babel presets and an
- * undocumented internal config — we shell out to the package's public CLI, which
- * is the canonical, maintained source of that build pipeline.
- *
- * `sitevision-scripts build` runs build + zip + cleanup and writes the archive to
- * `dist/<appId>.zip` — the exact path the CLI's own sign/deploy steps already use.
- */
-/**
- * Resolve the path to the sitevision-scripts CLI entry inside a project.
- * Returns null if the package is not installed.
- */
-export declare function getSitevisionScriptsBin(projectRoot: string): string | null;
-/**
- * Whether the sitevision-scripts package is available in the project.
- */
-export declare function hasSitevisionScripts(projectRoot: string): boolean;
-/**
- * Path of the zip that `sitevision-scripts build` writes.
- *
- * IMPORTANT: this mirrors sitevision-scripts' own app-id convention
- * (`APP_ID_PREFIX`/`APP_ID_SUFFIX` env vars + `dist/<appId>.zip`), which differs
- * from the CLI's own `getZipPath` env vars (`SITEVISION_APP_ID_*`). For delegated
- * builds the package is the one writing the file, so its convention is the source
- * of truth — using `getZipPath` here would look for the wrong filename whenever a
- * prefix/suffix is configured.
- */
-export declare function getDelegatedZipPath(projectRoot: string, manifestId: string): string;
-/**
- * Range of the sitevision-scripts package the CLI's build delegation has been
- * validated against. The delegation depends on the package's CLI commands, its
- * `dist/<appId>.zip` output, and the app-id convention — all stable within a
- * major. A new major may change that contract, so we warn rather than assume.
- *
- * Bump these (and re-validate) when adopting a new sitevision-scripts major.
- */
-export declare const SUPPORTED_SITEVISION_SCRIPTS_MIN = "8.0.0";
-/** Human-readable supported range, e.g. ">=8.0.0 <9.0.0". */
-export declare const SUPPORTED_SITEVISION_SCRIPTS_RANGE = ">=8.0.0 <9.0.0";
-export type SitevisionScriptsCompatStatus = 'ok' | 'too-old' | 'too-new' | 'not-installed' | 'unknown';
-export interface SitevisionScriptsCompat {
-    installed: string | null;
-    supportedRange: string;
-    status: SitevisionScriptsCompatStatus;
-    /** Populated for 'too-old'/'too-new' — a ready-to-display warning. */
-    warning?: string;
-}
-/**
- * Read the installed sitevision-scripts version from the project, or null if it
- * is not installed / unreadable.
- */
-export declare function getSitevisionScriptsVersion(projectRoot: string): string | null;
-/**
- * Check the project's installed sitevision-scripts against the supported range.
- * Use the `warning` field to surface a message when the version has drifted.
- */
-export declare function checkSitevisionScriptsCompatibility(projectRoot: string): SitevisionScriptsCompat;
-export interface SitevisionBuildResult {
-    success: boolean;
-    /** Combined stdout/stderr (tail-trimmed) for error reporting. */
-    output: string;
-    error?: string;
-}
-/**
- * Run `sitevision-scripts build` (build + zip + cleanup) as a subprocess.
- *
- * The package's own webpack pipeline produces the deployable `dist/<appId>.zip`.
- * Invoked via the current Node binary so it works cross-platform without relying
- * on the `node_modules/.bin` shims or shell PATH resolution.
- *
- * @param projectRoot - Project root directory (used as cwd)
- * @param onOutput - Optional callback for streaming output chunks
- * @param signal - Aborting kills the build and everything it started
- */
-export declare function runSitevisionScriptsBuild(projectRoot: string, onOutput?: (chunk: string) => void, signal?: AbortSignal): Promise<SitevisionBuildResult>;

package/dist/utils/tasks.d.ts

@@ -1,61 +0,0 @@
-import type { ProjectInfo, SigningCredentials, DeployConfig } from '../types/index.js';
-export type TaskKind = 'dev' | 'watch' | 'build' | 'sign' | 'deploy' | 'activate' | 'install' | 'create';
-export type TaskStatus = 'running' | 'success' | 'error' | 'stopped';
-export type LogLevel = 'info' | 'ok' | 'warn' | 'error';
-export interface LogLine {
-    time: number;
-    tag: string;
-    level: LogLevel;
-    text: string;
-}
-export interface Task {
-    id: number;
-    kind: TaskKind;
-    appRoot: string;
-    appName: string;
-    label: string;
-    status: TaskStatus;
-    phase: string;
-    startedAt: number;
-    endedAt?: number;
-    lines: LogLine[];
-    error?: string;
-    stop: () => void;
-}
-export declare function getTasks(): Task[];
-export declare function useTasks(): Task[];
-export declare function runningTasks(appRoot?: string): Task[];
-export declare function clearFinished(): void;
-type Log = (tag: string, text: string, level?: LogLevel) => void;
-export declare function createTask(kind: TaskKind, project: {
-    root: string;
-    manifest: Pick<ProjectInfo['manifest'], 'name' | 'id'>;
-}, label: string, stop?: () => void): {
-    task: Task;
-    log: Log;
-    finish: (status: TaskStatus, error?: string) => void;
-};
-export declare function setPhase(task: Task, phase: string): void;
-export interface DeployOptions {
-    force?: boolean;
-    production?: boolean;
-    activate?: boolean;
-    onAddonMissing?: (addonName: string) => Promise<boolean>;
-}
-export declare function startBuild(project: ProjectInfo): Task;
-export declare function startSign(project: ProjectInfo, credentials: SigningCredentials): Task;
-export declare function startDeploy(project: ProjectInfo, config: DeployConfig, options: DeployOptions): Task;
-export declare function startActivate(project: ProjectInfo, config: DeployConfig, executableId: string, versionLabel: string): Task;
-export declare function startInstall(project: ProjectInfo): Task;
-export interface DevOptions {
-    deploy: boolean;
-    signingCredentials?: SigningCredentials;
-    deployConfig?: DeployConfig;
-    onAddonMissing?: DeployOptions['onAddonMissing'];
-}
-/**
- * Dev / watch loop: build on every source change, then optionally sign and
- * deploy. Runs until `task.stop()`; the task stays in the registry meanwhile.
- */
-export declare function startDev(project: ProjectInfo, options: DevOptions): Task;
-export {};

package/dist/utils/version-check.d.ts

@@ -1,9 +0,0 @@
-/**
- * Check the npm registry for a newer published version of `packageName`.
- *
- * Resolves to the latest version string when it is newer than
- * `currentVersion`, otherwise `null`. Never rejects — network errors,
- * timeouts, non-200 responses and parse failures all resolve to `null`, so a
- * failed check never blocks startup or surfaces an error to the user.
- */
-export declare function checkForUpdate(packageName: string, currentVersion: string, timeoutMs?: number): Promise<string | null>;

package/dist/utils/webpack-runner.d.ts

@@ -1,76 +0,0 @@
-/**
- * Webpack Runner
- *
- * Handles webpack compilation for Sitevision apps.
- * Dynamically loads webpack from the target project's node_modules.
- */
-import type { BuildOptions, BuildResult } from '../types/index.js';
-/**
- * Find the project's own webpack config, or null if it has none.
- */
-export declare function findLocalWebpackConfig(projectRoot: string): string | null;
-/**
- * Whether the project ships its own webpack config (in-house build path),
- * as opposed to relying on the sitevision-scripts package.
- */
-export declare function hasLocalWebpackConfig(projectRoot: string): boolean;
-export declare class WebpackRunner {
-    private webpack;
-    private config;
-    private compiler;
-    private watcher;
-    private readonly projectRoot;
-    private readonly options;
-    constructor(projectRoot: string, options: BuildOptions);
-    /**
-     * Initialize webpack by loading it from the project's node_modules
-     */
-    private initialize;
-    /**
-     * Load webpack configuration from the project
-     */
-    private loadConfig;
-    /**
-     * Convert webpack stats to BuildResult
-     */
-    private statsToResult;
-    /**
-     * Run a single webpack build
-     */
-    run(): Promise<BuildResult>;
-    /**
-     * Start webpack in watch mode
-     *
-     * @param callback - Called after each compilation
-     */
-    watch(callback?: (result: BuildResult) => void): Promise<void>;
-    /**
-     * Stop watching and close the compiler
-     */
-    close(): Promise<void>;
-    /**
-     * Check if webpack is available in the project
-     */
-    static isWebpackAvailable(projectRoot: string): boolean;
-    /**
-     * Get the webpack version from the project
-     */
-    static getWebpackVersion(projectRoot: string): string | null;
-}
-/**
- * Run a single webpack build
- *
- * @param projectRoot - Project root directory
- * @param options - Build options
- * @returns Build result
- */
-export declare function runWebpackBuild(projectRoot: string, options: BuildOptions): Promise<BuildResult>;
-/**
- * Start webpack in watch mode
- *
- * @param projectRoot - Project root directory
- * @param options - Build options
- * @param callback - Called after each compilation
- * @returns WebpackRunner instance (call .close() to stop)
- */
-export declare function startWebpackWatch(projectRoot: string, options: BuildOptions, callback?: (result: BuildResult) => void): Promise<WebpackRunner>;