open-multi-agent-kit 0.79.1 → 0.80.0

package/dist/brand/theme-compiled.js

@@ -0,0 +1,241 @@
+/**
+ * OMK brand -- theme-compiled color source (theme contract T5b).
+ *
+ * Single bridge between canonical omk.theme.v1 documents and the brand
+ * palette/UI layers. Brand chrome defaults to night-city for byte parity, and
+ * can be switched at process edges to rust-forge without changing import shapes.
+ *
+ * Imports target the concrete src/cli/theme modules (render-table,
+ * terminal-capability, oklab-quantize) rather than the barrel to avoid a
+ * module cycle through theme-registry -> theme/colors -> brand/palette.
+ */
+import { compileTheme } from "../cli/theme/render-table.js";
+import { detectColorTier } from "../cli/theme/terminal-capability.js";
+import { hexToRgb255, normalizeHex } from "../cli/theme/oklab-quantize.js";
+import nightCityThemeJson from "./night-city.theme.json" with { type: "json" };
+import rustForgeThemeJson from "./rust-forge.theme.json" with { type: "json" };
+const REQUIRED_NIGHT_CITY_PRIMITIVES = [
+    "dark",
+    "surface",
+    "cyan",
+    "mint",
+    "magenta",
+    "purple",
+    "amber",
+    "red",
+    "cream",
+    "muted",
+    "gray",
+];
+const REQUIRED_RUST_FORGE_PRIMITIVES = [
+    "iron",
+    "coal",
+    "forge",
+    "anvil",
+    "rust",
+    "molten",
+    "copper",
+    "ember",
+    "oxide",
+    "quench",
+    "verdigris",
+    "crimson",
+    "steel",
+    "scale",
+    "ash",
+    "slag",
+    "bone",
+];
+function assertThemeDocument(doc, expectedName, requiredPrimitives) {
+    if (typeof doc !== "object" || doc === null) {
+        throw new Error(`brand theme-compiled: ${expectedName} theme snapshot is not an object`);
+    }
+    const candidate = doc;
+    if (candidate.schemaVersion !== "omk.theme.v1") {
+        throw new Error(`brand theme-compiled: expected schemaVersion "omk.theme.v1", got "${String(candidate.schemaVersion)}"`);
+    }
+    if (candidate.name !== expectedName) {
+        throw new Error(`brand theme-compiled: expected theme name "${expectedName}", got "${String(candidate.name)}"`);
+    }
+    if (typeof candidate.primitives !== "object" || candidate.primitives === null) {
+        throw new Error(`brand theme-compiled: ${expectedName} theme snapshot has no primitives map`);
+    }
+    if (typeof candidate.semantics !== "object" || candidate.semantics === null) {
+        throw new Error(`brand theme-compiled: ${expectedName} theme snapshot has no semantics map`);
+    }
+    if (typeof candidate.fallback16 !== "object" || candidate.fallback16 === null) {
+        throw new Error(`brand theme-compiled: ${expectedName} theme snapshot has no fallback16 map`);
+    }
+    const primitives = candidate.primitives;
+    for (const name of requiredPrimitives) {
+        if (typeof primitives[name] !== "string") {
+            throw new Error(`brand theme-compiled: ${expectedName} theme snapshot is missing primitive "${name}"`);
+        }
+    }
+    return doc;
+}
+/** Validated night-city theme document (build-time snapshot of themes/). */
+export const NIGHT_CITY_THEME = assertThemeDocument(nightCityThemeJson, "night-city", REQUIRED_NIGHT_CITY_PRIMITIVES);
+/** Validated rust-forge theme document (build-time snapshot of themes/). */
+export const RUST_FORGE_THEME = assertThemeDocument(rustForgeThemeJson, "rust-forge", REQUIRED_RUST_FORGE_PRIMITIVES);
+const BRAND_THEME_BY_NAME = {
+    "night-city": NIGHT_CITY_THEME,
+    "rust-forge": RUST_FORGE_THEME,
+};
+let activeBrandThemeName = "night-city";
+export function resolveBrandThemeName(name) {
+    const normalized = name?.trim().toLowerCase();
+    if (normalized === "rust-forge" ||
+        normalized === "rust" ||
+        normalized === "cargo" ||
+        normalized === "oxide" ||
+        normalized === "forge" ||
+        normalized === "oxidized-forge" ||
+        normalized === "oxidized" ||
+        normalized === "rust-native") {
+        return "rust-forge";
+    }
+    return "night-city";
+}
+export function setActiveBrandTheme(name) {
+    activeBrandThemeName = resolveBrandThemeName(name);
+    return activeBrandThemeName;
+}
+export function getActiveBrandThemeName() {
+    return activeBrandThemeName;
+}
+export function getActiveBrandTheme() {
+    return BRAND_THEME_BY_NAME[activeBrandThemeName];
+}
+function hexByRole(theme, role) {
+    const semantic = theme.semantics[role];
+    if (semantic === undefined) {
+        throw new Error(`brand theme-compiled: theme "${theme.name}" has no semantic role "${role}"`);
+    }
+    const raw = theme.primitives[semantic.color];
+    if (raw === undefined) {
+        throw new Error(`brand theme-compiled: theme "${theme.name}" semantic "${role}" references missing primitive "${semantic.color}"`);
+    }
+    return normalizeHex(raw);
+}
+export function activeThemeHexByRole(role) {
+    return hexByRole(getActiveBrandTheme(), role);
+}
+export function brandThemeHexByRole(name, role) {
+    return hexByRole(BRAND_THEME_BY_NAME[name], role);
+}
+export function brandThemeRgbByRole(name, role) {
+    const [r, g, b] = hexToRgb255(brandThemeHexByRole(name, role));
+    return { r, g, b };
+}
+export function activeThemeRgbByRole(role) {
+    const [r, g, b] = hexToRgb255(activeThemeHexByRole(role));
+    return { r, g, b };
+}
+const PRIMITIVE_ROLE_ALIASES = {
+    cyan: "route.active",
+    mint: "evidence.pass",
+    magenta: "control.accent",
+    purple: "control.accent",
+    amber: "route.fallback",
+    red: "telemetry.error",
+    cream: "control.fg",
+    muted: "dag.lane.queued",
+    gray: "control.dim",
+    dark: "control.bg",
+};
+export function activeThemeHexByPrimitive(primitive) {
+    const theme = getActiveBrandTheme();
+    const raw = theme.primitives[primitive];
+    if (raw !== undefined)
+        return normalizeHex(raw);
+    if (primitive === "surface") {
+        const surfacePrimitive = theme.backgrounds[1] ?? theme.backgrounds[0];
+        const surface = surfacePrimitive ? theme.primitives[surfacePrimitive] : undefined;
+        return surface === undefined ? activeThemeHexByRole("control.bg") : normalizeHex(surface);
+    }
+    const role = PRIMITIVE_ROLE_ALIASES[primitive];
+    if (role !== undefined)
+        return activeThemeHexByRole(role);
+    throw new Error(`brand theme-compiled: theme "${theme.name}" has no primitive "${primitive}"`);
+}
+/** Canonical normalized uppercase hex string for a night-city primitive. */
+export function nightCityHex(primitive) {
+    const raw = NIGHT_CITY_THEME.primitives[primitive];
+    if (raw === undefined) {
+        throw new Error(`brand theme-compiled: unknown night-city primitive "${primitive}"`);
+    }
+    return normalizeHex(raw);
+}
+/** 0-255 RGB triple for a night-city primitive. */
+export function nightCityRgb(primitive) {
+    const [r, g, b] = hexToRgb255(nightCityHex(primitive));
+    return { r, g, b };
+}
+function channelHex(value) {
+    const clamped = Math.max(0, Math.min(255, Math.round(value)));
+    return clamped.toString(16).padStart(2, "0").toUpperCase();
+}
+/** Convert an RGB triple to canonical uppercase hex (no literal hex in source). */
+export function rgbToHex(color) {
+    return `#${channelHex(color.r)}${channelHex(color.g)}${channelHex(color.b)}`;
+}
+const compiledByThemeAndTier = new Map();
+/**
+ * Compiled active brand render table for the requested (default: detected)
+ * degradation tier. The cache key includes both theme name and tier.
+ */
+export function getCompiledBrandTheme(tier = detectColorTier()) {
+    const theme = getActiveBrandTheme();
+    const cacheKey = `${theme.name}:${tier}`;
+    const cached = compiledByThemeAndTier.get(cacheKey);
+    if (cached !== undefined)
+        return cached;
+    const compiled = compileTheme(theme, tier);
+    compiledByThemeAndTier.set(cacheKey, compiled);
+    return compiled;
+}
+/** Paint text with an active-brand semantic token at the detected color tier. */
+export function brandPaint(role, text) {
+    return getCompiledBrandTheme().paint(role, text);
+}
+export function getActiveBrandChromeLabel() {
+    return activeBrandThemeName === "rust-forge" ? "Oxidized Forge" : "Night City";
+}
+export function getActiveBrandCockpitSubtitle() {
+    return activeBrandThemeName === "rust-forge"
+        ? "OXIDIZED FORGE · ROUTE · VERIFY · CONTROL"
+        : "NEON GRID · GREEN RAIN · METRICS WALL";
+}
+export function getActiveBrandCockpitDetail() {
+    return activeBrandThemeName === "rust-forge"
+        ? "forge heat · anvil evidence · quench safety · OMK control"
+        : "route · verify · loop · control · evidence gated";
+}
+export function getActiveBrandHudStatus() {
+    return activeBrandThemeName === "rust-forge" ? "OXIDIZED FORGE ONLINE" : "NEON GRID ONLINE";
+}
+export function getActiveBrandConsoleLine() {
+    return activeBrandThemeName === "rust-forge"
+        ? "Oxidized Forge Console // OMK independent control // heat anvil quench"
+        : "Night City Ops Console // cyberpunk metrics wall";
+}
+/**
+ * Unconditional truecolor SGR open sequence for a brand RGB value, produced
+ * through the theme compiler (single SGR factory -- no escape literals here).
+ * Brand theme constants intentionally stay truecolor for byte parity with the
+ * legacy palette; tier-aware rendering should use `getCompiledBrandTheme()`.
+ */
+export function brandTruecolorSgr(color) {
+    const inlineTheme = {
+        schemaVersion: "omk.theme.v1",
+        name: "omk-brand-inline",
+        mode: "dark",
+        primitives: { brand: rgbToHex(color) },
+        backgrounds: [],
+        semantics: { "brand.tone": { color: "brand", usage: "text" } },
+        components: {},
+        fallback16: { "brand.tone": "white" },
+    };
+    return compileTheme(inlineTheme, "truecolor").tokens["brand.tone"].sgr;
+}

package/dist/brand/theme.d.ts

@@ -0,0 +1,41 @@
+export type OmkBrandThemeName = "system24" | "green-rain" | "neon-grid" | "rust-forge" | "plain" | "high-contrast" | "matrix";
+export type OmkTuiMotion = "off" | "low" | "auto" | "full";
+export interface OmkBrandTheme {
+    name: OmkBrandThemeName;
+    label: string;
+    tagline: string;
+    motto: string;
+    symbols: {
+        prompt: string;
+        active: string;
+        done: string;
+        failed: string;
+        pending: string;
+        signal: string;
+    };
+    colors: {
+        border: string;
+        borderHot: string;
+        text: string;
+        muted: string;
+        primary: string;
+        success: string;
+        warning: string;
+        danger: string;
+        info: string;
+    };
+    motion: {
+        rain: boolean;
+        spinner: "braille" | "scanline" | "none";
+    };
+}
+export declare const SYSTEM24_THEME: OmkBrandTheme;
+export declare const GREEN_RAIN_THEME: OmkBrandTheme;
+export declare const NEON_GRID_THEME: OmkBrandTheme;
+export declare const RUST_FORGE_THEME: OmkBrandTheme;
+export declare const MATRIX_THEME: OmkBrandTheme;
+export declare const PLAIN_THEME: OmkBrandTheme;
+export declare const HIGH_CONTRAST_THEME: OmkBrandTheme;
+export declare function resolveOmkBrandTheme(name: string | undefined): OmkBrandTheme;
+export declare function shouldUseAnsiColor(env?: NodeJS.ProcessEnv): boolean;
+export declare function resolveTuiMotion(env?: NodeJS.ProcessEnv): OmkTuiMotion;

package/dist/brand/theme.js

@@ -0,0 +1,275 @@
+import { P } from "./palette.js";
+import { brandThemeRgbByRole, brandTruecolorSgr } from "./theme-compiled.js";
+/**
+ * Truecolor SGR open sequence for a brand color, produced via the theme
+ * compiler (compileTheme) — no raw escape literals in this file. Brand theme
+ * constants stay truecolor on purpose for byte parity; tier-aware rendering
+ * lives in src/brand/theme-compiled.ts (getCompiledBrandTheme).
+ */
+function fg(color) {
+    return brandTruecolorSgr(color);
+}
+function rgb(r, g, b) {
+    return fg({ r, g, b });
+}
+function rustFg(role) {
+    return brandTruecolorSgr(brandThemeRgbByRole("rust-forge", role));
+}
+export const SYSTEM24_THEME = {
+    name: "system24",
+    label: "OMK System24",
+    tagline: "OMK operator console for routed agent work.",
+    motto: "Route the work. Verify the evidence. Control the loop.",
+    symbols: {
+        prompt: "›",
+        active: "▶",
+        done: "✓",
+        failed: "✕",
+        pending: "□",
+        signal: "◆",
+    },
+    colors: {
+        border: rgb(85, 85, 85),
+        borderHot: rgb(140, 140, 140),
+        text: rgb(242, 242, 242),
+        muted: rgb(153, 153, 153),
+        primary: rgb(167, 139, 250),
+        success: rgb(102, 204, 153),
+        warning: rgb(245, 191, 102),
+        danger: rgb(242, 143, 143),
+        info: rgb(102, 204, 217),
+    },
+    motion: {
+        rain: false,
+        spinner: "braille",
+    },
+};
+export const GREEN_RAIN_THEME = {
+    name: "green-rain",
+    label: "OMK Green Rain",
+    tagline: "Provider-neutral Green Rain signal console.",
+    motto: "Follow the signal. Verify the evidence. Control the loop.",
+    symbols: {
+        prompt: "›",
+        active: "▶",
+        done: "✓",
+        failed: "✕",
+        pending: "□",
+        signal: "◆",
+    },
+    colors: {
+        border: fg(P.matrixDark),
+        borderHot: fg(P.mint),
+        text: fg(P.cream),
+        muted: fg(P.gray),
+        primary: fg(P.mint),
+        success: fg(P.mint),
+        warning: fg(P.orange),
+        danger: fg(P.red),
+        info: fg(P.blue),
+    },
+    motion: {
+        rain: true,
+        spinner: "scanline",
+    },
+};
+export const NEON_GRID_THEME = {
+    name: "neon-grid",
+    label: "OMK//CONTROL",
+    tagline: "Cyberpunk OMK control plane for routed agent work.",
+    motto: "Control the loop — route · verify · loop · control",
+    symbols: {
+        prompt: "›",
+        active: "●",
+        done: "✓",
+        failed: "✕",
+        pending: "○",
+        signal: "◇",
+    },
+    colors: {
+        border: fg(P.gridLine),
+        borderHot: fg(P.blue),
+        text: fg(P.cream),
+        muted: fg(P.gray),
+        primary: fg(P.blue),
+        success: fg(P.mint),
+        warning: fg(P.orange),
+        danger: fg(P.red),
+        info: fg(P.blue),
+    },
+    motion: {
+        rain: false,
+        spinner: "scanline",
+    },
+};
+export const RUST_FORGE_THEME = {
+    name: "rust-forge",
+    label: "OMK Rust Forge",
+    tagline: "Oxidized forge console for standalone OMK control.",
+    motto: "Forge the route. Verify the evidence. OMK controls the loop.",
+    symbols: {
+        prompt: "›",
+        active: "◉",
+        done: "✓",
+        failed: "✕",
+        pending: "□",
+        signal: "▣",
+    },
+    colors: {
+        border: rustFg("route.fallback"),
+        borderHot: rustFg("control.accent"),
+        text: rustFg("control.fg"),
+        muted: rustFg("control.dim"),
+        primary: rustFg("control.accent"),
+        success: rustFg("evidence.pass"),
+        warning: rustFg("telemetry.warn"),
+        danger: rustFg("telemetry.error"),
+        info: rustFg("route.active"),
+    },
+    motion: {
+        rain: false,
+        spinner: "braille",
+    },
+};
+export const MATRIX_THEME = {
+    name: "matrix",
+    label: "OMK Matrix",
+    tagline: "Matrix rain code console for OMK orchestration.",
+    motto: "Follow the white rabbit. Verify the evidence. Control the loop.",
+    symbols: {
+        prompt: "›",
+        active: "⏵",
+        done: "✓",
+        failed: "✕",
+        pending: "○",
+        signal: "⏣",
+    },
+    colors: {
+        border: rgb(0, 20, 0),
+        borderHot: fg(P.matrixRainGreen),
+        text: rgb(200, 255, 200),
+        muted: fg(P.matrixRainDim),
+        primary: fg(P.matrixRainGreen),
+        success: fg(P.matrixRainGreen),
+        warning: fg(P.matrixWarningAmber),
+        danger: fg(P.matrixErrorRed),
+        info: rgb(0, 200, 50),
+    },
+    motion: {
+        rain: true,
+        spinner: "scanline",
+    },
+};
+export const PLAIN_THEME = {
+    name: "plain",
+    label: "OMK Plain",
+    tagline: "OMK operator console.",
+    motto: "Route the work. Verify the evidence. Control the loop.",
+    symbols: {
+        prompt: ">",
+        active: ">",
+        done: "ok",
+        failed: "x",
+        pending: "-",
+        signal: "*",
+    },
+    colors: {
+        border: "",
+        borderHot: "",
+        text: "",
+        muted: "",
+        primary: "",
+        success: "",
+        warning: "",
+        danger: "",
+        info: "",
+    },
+    motion: {
+        rain: false,
+        spinner: "none",
+    },
+};
+export const HIGH_CONTRAST_THEME = {
+    name: "high-contrast",
+    label: "OMK High Contrast",
+    tagline: "High-contrast OMK operator console.",
+    motto: "Route the work. Verify the evidence. Control the loop.",
+    symbols: {
+        prompt: "›",
+        active: "▶",
+        done: "✓",
+        failed: "✕",
+        pending: "□",
+        signal: "◆",
+    },
+    colors: {
+        border: rgb(210, 210, 210),
+        borderHot: rgb(255, 255, 255),
+        text: rgb(255, 255, 255),
+        muted: rgb(210, 210, 210),
+        primary: rgb(255, 255, 255),
+        success: rgb(140, 255, 140),
+        warning: rgb(255, 230, 120),
+        danger: rgb(255, 120, 120),
+        info: rgb(140, 220, 255),
+    },
+    motion: {
+        rain: false,
+        spinner: "braille",
+    },
+};
+export function resolveOmkBrandTheme(name) {
+    const normalized = name?.trim().toLowerCase();
+    if (normalized === "green-rain" ||
+        normalized === "green" ||
+        normalized === "phosphor")
+        return GREEN_RAIN_THEME;
+    if (normalized === "matrix" ||
+        normalized === "matrix-rain" ||
+        normalized === "neo" ||
+        normalized === "zion" ||
+        normalized === "rain")
+        return MATRIX_THEME;
+    if (normalized === "neon-grid" ||
+        normalized === "neon" ||
+        normalized === "grid" ||
+        normalized === "control" ||
+        normalized === "omk-control" ||
+        normalized === "night-city" ||
+        normalized === "night-city-ops" ||
+        normalized === "metrics" ||
+        normalized === "metrics-control" ||
+        normalized === "cyberpunk")
+        return NEON_GRID_THEME;
+    if (normalized === "rust-forge" ||
+        normalized === "rust" ||
+        normalized === "cargo" ||
+        normalized === "oxide" ||
+        normalized === "forge" ||
+        normalized === "rust-native")
+        return RUST_FORGE_THEME;
+    if (normalized === "plain")
+        return PLAIN_THEME;
+    if (normalized === "high-contrast" || normalized === "contrast")
+        return HIGH_CONTRAST_THEME;
+    return SYSTEM24_THEME;
+}
+export function shouldUseAnsiColor(env = process.env) {
+    if (env.NO_COLOR !== undefined || env.TERM === "dumb")
+        return false;
+    return true;
+}
+export function resolveTuiMotion(env = process.env) {
+    if (env.NO_COLOR !== undefined ||
+        env.CI === "true" ||
+        env.CI === "1" ||
+        env.TERM === "dumb")
+        return "off";
+    const normalized = env.OMK_ANIMATION?.trim().toLowerCase();
+    if (normalized === "off" ||
+        normalized === "low" ||
+        normalized === "auto" ||
+        normalized === "full")
+        return normalized;
+    return "auto";
+}

package/dist/browser/browser-feedback.d.ts

@@ -0,0 +1,10 @@
+import type { BrowserObservation } from "./browser-observer.js";
+export interface BrowserFeedbackResult {
+    ok: boolean;
+    observation?: BrowserObservation;
+    error?: string;
+}
+export declare function openAndObserve(url: string, headless?: boolean): Promise<BrowserFeedbackResult>;
+export declare function submitFeedback(sessionId: string, text: string): Promise<BrowserFeedbackResult>;
+export declare function closeActiveSession(): Promise<BrowserFeedbackResult>;
+export declare function inspectSession(sessionId?: string): Promise<BrowserFeedbackResult>;

package/dist/browser/browser-feedback.js

@@ -0,0 +1,84 @@
+import { CliError } from "../util/cli-contract.js";
+import { join } from "path";
+import { createBrowserSession, getActiveBrowserSession, closeBrowserSession, getBrowserSessionDir, } from "./browser-session.js";
+import { observeBrowserPage, writeBrowserFeedback, readBrowserObservation } from "./browser-observer.js";
+export async function openAndObserve(url, headless) {
+    try {
+        const session = await createBrowserSession({ url, headless });
+        const observation = await observeBrowserPage(session);
+        return { ok: true, observation };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export async function submitFeedback(sessionId, text) {
+    try {
+        await writeBrowserFeedback(sessionId, text);
+        const observation = await readBrowserObservation(sessionId);
+        const observationPath = join(getBrowserSessionDir(undefined, sessionId), "observation.json");
+        import("../hooks/hook-bus.js")
+            .then(({ emit }) => emit({
+            type: "browser.feedback.submitted",
+            payload: {
+                sessionId,
+                feedbackText: text,
+                observationPath,
+            },
+        }))
+            .catch(() => {
+            // ignore hook emission failures
+        });
+        return { ok: true, observation };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export async function closeActiveSession() {
+    try {
+        await closeBrowserSession();
+        return { ok: true };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export async function inspectSession(sessionId) {
+    try {
+        const active = getActiveBrowserSession();
+        if (active) {
+            if (sessionId && active.sessionId !== sessionId) {
+                return {
+                    ok: false,
+                    error: `Active session (${active.sessionId}) does not match requested session (${sessionId}).`,
+                };
+            }
+            const observation = await observeBrowserPage(active);
+            return { ok: true, observation };
+        }
+        if (!sessionId) {
+            throw new CliError("No active browser session. Run: omk browser open <url>");
+        }
+        const observation = await readBrowserObservation(sessionId);
+        if (!observation) {
+            throw new CliError(`No observation found for session ${sessionId}`);
+        }
+        return { ok: true, observation };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}

package/dist/browser/browser-observer.d.ts

@@ -0,0 +1,21 @@
+import type { BrowserSession } from "./browser-session.js";
+export interface BrowserObservation {
+    sessionId: string;
+    url: string;
+    title: string;
+    viewport: {
+        width: number;
+        height: number;
+        deviceScaleFactor: number;
+    };
+    screenshotPath: string;
+    domSnapshotPath: string;
+    consoleEventsPath: string;
+    networkEventsPath: string;
+    accessibilityPath?: string;
+    capturedAt: string;
+}
+export declare function observeBrowserPage(session: BrowserSession, projectRoot?: string): Promise<BrowserObservation>;
+export declare function writeBrowserFeedback(sessionId: string, feedbackText: string, projectRoot?: string): Promise<void>;
+export declare function readBrowserObservation(sessionId: string, projectRoot?: string): Promise<BrowserObservation | undefined>;
+export declare function saveBrowserObservation(observation: BrowserObservation, projectRoot?: string): Promise<void>;