@rizom/ops 0.2.0-alpha.55 → 0.2.0-alpha.551

package/dist/directory-sync-stress-system.d.ts

@@ -0,0 +1,75 @@
+import type { FetchLike } from "@brains/utils/fetch-like";
+import { type DirectorySyncStressPhase, type DirectorySyncStressPlan, type DirectorySyncStressProfile, type DirectorySyncStressReport, type StressRuntimeSample } from "./directory-sync-stress";
+import { type StressCommandRunner } from "./stress-command";
+export { runStressCommand, type StressCommandOptions, type StressCommandResult, type StressCommandRunner, } from "./stress-command";
+export interface DeployedDirectorySyncStressOptions {
+    rootDir: string;
+    handle: string;
+    profile: DirectorySyncStressProfile;
+    plan?: DirectorySyncStressPlan;
+    confirmation: string;
+    artifactsDir?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+    commandRunner?: StressCommandRunner;
+    logger?: (message: string) => void;
+    now?: () => Date;
+    sleep?: (milliseconds: number) => Promise<void>;
+}
+export interface VerifyDirectorySyncStressAccessOptions {
+    rootDir: string;
+    handle: string;
+    confirmation: string;
+    artifactsDir?: string;
+    env?: NodeJS.ProcessEnv;
+    commandRunner?: StressCommandRunner;
+    now?: () => Date;
+}
+export interface CleanupDirectorySyncStressOptions {
+    rootDir: string;
+    handle: string;
+    confirmation: string;
+    artifactsDir?: string;
+    env?: NodeJS.ProcessEnv;
+    commandRunner?: StressCommandRunner;
+    logger?: (message: string) => void;
+    now?: () => Date;
+}
+export interface DeployedDirectorySyncStressResult {
+    runId: string;
+    artifactsDir: string;
+    target: {
+        handle: string;
+        domain: string;
+        contentRepo: string;
+    };
+    startedAt: string;
+    completedAt: string;
+    report: DirectorySyncStressReport;
+}
+export interface VerifyDirectorySyncStressAccessResult {
+    success: true;
+    artifactsDir: string;
+    checkedAt: string;
+    remoteHead: string;
+    target: {
+        handle: string;
+        domain: string;
+        contentRepo: string;
+    };
+}
+export interface CleanupDirectorySyncStressResult {
+    success: boolean;
+    artifactsDir: string;
+    probesRemoved: number;
+    probesRemaining: number;
+    backupBranchesDeleted: string[];
+    cleanupCommit?: string;
+}
+export declare function runDeployedDirectorySyncStress(options: DeployedDirectorySyncStressOptions): Promise<DeployedDirectorySyncStressResult>;
+export declare function verifyDirectorySyncStressAccess(options: VerifyDirectorySyncStressAccessOptions): Promise<VerifyDirectorySyncStressAccessResult>;
+export declare function cleanupDirectorySyncStress(options: CleanupDirectorySyncStressOptions): Promise<CleanupDirectorySyncStressResult>;
+export declare function applyDirectorySyncStressPhase(checkoutDir: string, phase: DirectorySyncStressPhase): Promise<void>;
+export declare function listProbeFiles(checkoutDir: string): Promise<string[]>;
+export declare function removeProbeFiles(checkoutDir: string): Promise<number>;
+export declare function parseStressRuntimeSample(output: string, timestamp: string): StressRuntimeSample | undefined;

package/dist/directory-sync-stress.d.ts

@@ -0,0 +1,117 @@
+import type { FetchLike } from "@brains/utils/fetch-like";
+import { z } from "@brains/utils/zod";
+export declare const directorySyncStressProfileSchema: z.ZodEnum<{
+    regression: "regression";
+    load: "load";
+    stress: "stress";
+}>;
+export type DirectorySyncStressProfile = z.output<typeof directorySyncStressProfileSchema>;
+export declare const directorySyncStressOperationSchema: z.ZodEnum<{
+    add: "add";
+    update: "update";
+    rename: "rename";
+    delete: "delete";
+}>;
+export type DirectorySyncStressOperation = z.output<typeof directorySyncStressOperationSchema>;
+export declare const directorySyncStressPhaseSchema: z.ZodObject<{
+    id: z.ZodString;
+    operation: typeof directorySyncStressOperationSchema;
+    count: z.ZodNumber;
+    targetProbeCount: z.ZodNumber;
+    settleMs: z.ZodNumber;
+}>;
+export type DirectorySyncStressPhase = z.output<typeof directorySyncStressPhaseSchema>;
+export declare const directorySyncStressPlanSchema: z.ZodObject<{
+    profile: typeof directorySyncStressProfileSchema;
+    maximumProbeCount: z.ZodNumber;
+    maximumExternalAiCalls: z.ZodOptional<z.ZodNumber>;
+    phases: z.ZodArray<typeof directorySyncStressPhaseSchema>;
+}>;
+export type DirectorySyncStressPlan = z.output<typeof directorySyncStressPlanSchema>;
+export declare const stressBaselineSchema: z.ZodObject<{
+    entities: z.ZodNumber;
+    notes: z.ZodNumber;
+    version: z.ZodString;
+}>;
+export type StressBaseline = z.output<typeof stressBaselineSchema>;
+export declare const stressHealthSampleSchema: z.ZodObject<{
+    timestamp: z.ZodISODateTime;
+    endpoint: z.ZodString;
+    status: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    ok: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}>;
+export type StressHealthSample = z.output<typeof stressHealthSampleSchema>;
+export declare const stressRuntimeSampleSchema: z.ZodObject<{
+    timestamp: z.ZodISODateTime;
+    cpuPercent: z.ZodNumber;
+    memoryPercent: z.ZodNumber;
+    pids: z.ZodNumber;
+}>;
+export type StressRuntimeSample = z.output<typeof stressRuntimeSampleSchema>;
+export declare const stressPhaseResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    operation: typeof directorySyncStressOperationSchema;
+    count: z.ZodNumber;
+    success: z.ZodBoolean;
+    commitLatencyMs: z.ZodOptional<z.ZodNumber>;
+    persistenceLatencyMs: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+}>;
+export type StressPhaseResult = z.output<typeof stressPhaseResultSchema>;
+export declare const stressCleanupResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    probesRemaining: z.ZodNumber;
+    finalEntities: z.ZodOptional<z.ZodNumber>;
+    finalNotes: z.ZodOptional<z.ZodNumber>;
+    contentTreeRestored: z.ZodOptional<z.ZodBoolean>;
+    error: z.ZodOptional<z.ZodString>;
+}>;
+export type StressCleanupResult = z.output<typeof stressCleanupResultSchema>;
+export declare const stressContainerStateSchema: z.ZodObject<{
+    status: z.ZodString;
+    restartCount: z.ZodNumber;
+    oomKilled: z.ZodBoolean;
+}>;
+export type StressContainerState = z.output<typeof stressContainerStateSchema>;
+export declare const stressMetricsSchema: z.ZodObject<{
+    health: z.ZodArray<typeof stressHealthSampleSchema>;
+    runtime: z.ZodArray<typeof stressRuntimeSampleSchema>;
+    externalAiCalls: z.ZodOptional<z.ZodNumber>;
+    container: z.ZodOptional<typeof stressContainerStateSchema>;
+}>;
+export type StressMetrics = z.output<typeof stressMetricsSchema>;
+export declare const directorySyncStressReportSchema: z.ZodObject<{
+    profile: typeof directorySyncStressProfileSchema;
+    success: z.ZodBoolean;
+    baseline: typeof stressBaselineSchema;
+    phases: z.ZodArray<typeof stressPhaseResultSchema>;
+    cleanup: typeof stressCleanupResultSchema;
+    metrics: typeof stressMetricsSchema;
+    failure: z.ZodOptional<z.ZodString>;
+}>;
+export type DirectorySyncStressReport = z.output<typeof directorySyncStressReportSchema>;
+export interface DirectorySyncStressTarget {
+    handle: string;
+    domain: string;
+    contentRepo: string;
+    confirmation: string;
+}
+export interface DirectorySyncStressDriver {
+    prepare(plan: DirectorySyncStressPlan): Promise<StressBaseline>;
+    startMonitoring(): Promise<void>;
+    executePhase(phase: DirectorySyncStressPhase, baseline: StressBaseline): Promise<StressPhaseResult>;
+    cleanup(baseline: StressBaseline): Promise<StressCleanupResult>;
+    stopMonitoring(): Promise<StressMetrics>;
+}
+export declare function resolveDirectorySyncStressPlan(profile: DirectorySyncStressProfile): DirectorySyncStressPlan;
+export declare function assertDirectorySyncStressTarget(target: DirectorySyncStressTarget): void;
+export interface SampleStressHealthOptions {
+    fetchImpl?: FetchLike;
+    now?: () => Date;
+    timeoutMs?: number;
+}
+export declare function sampleStressHealth(url: string, options?: SampleStressHealthOptions): Promise<StressHealthSample>;
+export declare function runDirectorySyncStressPlan(plan: DirectorySyncStressPlan, driver: DirectorySyncStressDriver): Promise<DirectorySyncStressReport>;
+export declare function stressMetricsFailure(metrics: StressMetrics, maximumExternalAiCalls?: number): string | undefined;

package/dist/entries/deploy.d.ts

@@ -1,2 +1,4 @@
-export { readJsonResponse, parseEnvFile, parseEnvSchema, parseEnvSchemaFile, requireEnv, writeGitHubOutput, writeGitHubEnv, } from "@brains/utils";
-export type { EnvSchemaEntry } from "@brains/utils";
+export { readJsonResponse, parseEnvFile, parseEnvSchema, parseEnvSchemaFile, requireEnv, writeGitHubOutput, writeGitHubEnv, } from "@brains/deploy-support";
+export { verifyRuntimeImage } from "../image-inventory";
+export type { EnvSchemaEntry } from "@brains/deploy-support";
+export { runtimeImageTag, sitePackagesFor, requiredImages, resolveImageBuilds, runResolveMissingImages, type ImageRequirementSource, type RequiredImage, type ResolveImageBuildsOptions, type RunResolveMissingImagesOptions, } from "../images";

package/dist/health-watchdog-smoke.d.ts

@@ -0,0 +1,54 @@
+import type { FetchLike } from "@brains/utils/fetch-like";
+import { type StressCommandRunner } from "./stress-command";
+export interface HealthWatchdogSmokeTarget {
+    handle: string;
+    domain: string;
+    confirmation: string;
+    runId: string;
+}
+export interface HealthWatchdogSmokeOptions {
+    rootDir: string;
+    handle: string;
+    confirmation: string;
+    runId: string;
+    artifactsDir?: string | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    fetchImpl?: FetchLike | undefined;
+    commandRunner?: StressCommandRunner | undefined;
+    logger?: ((message: string) => void) | undefined;
+}
+export interface HealthWatchdogSmokeResult {
+    success: true;
+    runId: string;
+    artifactsDir: string;
+    target: {
+        handle: string;
+        domain: string;
+        serverIp: string;
+    };
+}
+export interface CleanupHealthWatchdogSmokeOptions {
+    rootDir: string;
+    handle: string;
+    confirmation: string;
+    runId: string;
+    artifactsDir?: string | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    fetchImpl?: FetchLike | undefined;
+    commandRunner?: StressCommandRunner | undefined;
+    logger?: ((message: string) => void) | undefined;
+}
+export interface CleanupHealthWatchdogSmokeResult {
+    success: true;
+    runId: string;
+    artifactsDir: string;
+    target: {
+        handle: string;
+        domain: string;
+        serverIp: string;
+    };
+}
+export declare function assertHealthWatchdogSmokeTarget(target: HealthWatchdogSmokeTarget): void;
+export declare function renderHealthWatchdogSmokeRemoteScript(): string;
+export declare function runHealthWatchdogSmoke(options: HealthWatchdogSmokeOptions): Promise<HealthWatchdogSmokeResult>;
+export declare function cleanupHealthWatchdogSmoke(options: CleanupHealthWatchdogSmokeOptions): Promise<CleanupHealthWatchdogSmokeResult>;

package/dist/image-inventory.d.ts

@@ -0,0 +1,4 @@
+import type { RequiredImage } from "./image-types";
+import { type RunCommand } from "@brains/deploy-support/run-subprocess";
+/** Verify a published image without starting an app or touching a fleet host. */
+export declare function verifyRuntimeImage(imageRepository: string, image: RequiredImage, run?: RunCommand): Promise<void>;

package/dist/image-types.d.ts

@@ -0,0 +1,7 @@
+/** Exact runtime requirements shared by image planning and verification. */
+export interface RequiredImage {
+    tag: string;
+    brainVersion: string;
+    /** Sorted, deduped package specs installed into this runtime image. */
+    sitePackages: string[];
+}

package/dist/images.d.ts

@@ -0,0 +1,88 @@
+import type { RequiredImage } from "./image-types";
+export type { RequiredImage } from "./image-types";
+import { type ResolvedSiteOverride } from "./load-registry";
+import { type RunCommand } from "@brains/deploy-support/run-subprocess";
+/**
+ * Name the immutable runtime image for a Brain version and the exact site
+ * packages installed into it: `brain-<version>` for an instance without site
+ * pins, else that followed by each pin, sorted, in registry-safe spelling
+ * (`@rizom/site-x@1.2.3` → `rizom-site-x-1.2.3`). A pin set too long to spell
+ * out is named by a digest of it instead. Every instance with the same Brain
+ * version and pins shares one image; a change of pins is a new image, so a
+ * site can move on its own. Build and Deploy both import this function so
+ * their tags can never disagree.
+ */
+export declare function runtimeImageTag(brainVersion: string, sitePackages?: readonly string[]): string;
+/**
+ * The npm packages a site override contributes to every new fleet image.
+ * A @rizom-scoped theme is independently published and installs at its own
+ * explicit version; @brains/* themes are bundled inside @rizom/brain and must
+ * not be npm-installed.
+ */
+export declare function sitePackagesFor(siteOverride: ResolvedSiteOverride | undefined): string[];
+/** The per-user slice of the registry that determines which image it runs. */
+export interface ImageRequirementSource {
+    brainVersion: string;
+    siteOverride?: ResolvedSiteOverride | undefined;
+}
+/**
+ * Derive one immutable image per effective Brain version and site pin set:
+ * every instance runs the image named by its own version and pins, so a
+ * site's pin change builds that site's image and no other, and promoting an
+ * instance to a version keeps whatever image already carries its pins there.
+ */
+export declare function requiredImages(users: ImageRequirementSource[]): RequiredImage[];
+export interface ResolveImageBuildsOptions {
+    users: ImageRequirementSource[];
+    /**
+     * Explicit dispatch override — the manual/backfill path. When set, exactly
+     * one image is built: this version with exactly the dispatched pins.
+     * Published tags stay immutable: a same-tag rebuild from a newer Dockerfile
+     * can strand the tag boot-broken, so rebuilding needs allowTagOverwrite.
+     */
+    brainVersionInput?: string | undefined;
+    sitePackagesInput?: string | undefined;
+    allowTagOverwrite?: boolean | undefined;
+    imageExists: (tag: string) => Promise<boolean>;
+    /** Fail closed if a published image cannot serve its assigned instances. */
+    verifyImage: (image: RequiredImage) => Promise<void>;
+}
+/**
+ * Decide which images a Build run must produce: the declared required set
+ * filtered to tags the registry does not already hold, or the single image an
+ * explicit dispatch input forces.
+ */
+export declare function resolveImageBuilds(options: ResolveImageBuildsOptions): Promise<RequiredImage[]>;
+export interface RunResolveMissingImagesOptions {
+    rootDir: string;
+    /** e.g. `ghcr.io/rizom-ai/rover-pilot` */
+    imageRepository: string;
+    env?: NodeJS.ProcessEnv;
+    runCommand?: RunCommand;
+    writeOutput: (key: string, value: string) => void;
+    log?: (line: string) => void;
+}
+/**
+ * Whether the registry already holds this tag.
+ *
+ * `docker manifest inspect` exits non-zero when the manifest is unknown, so a
+ * command failure is the "absent" answer. A failure to run docker at all is
+ * not: answering false there would let resolveImageBuilds past its
+ * tag-immutability guard and overwrite a published tag, which is exactly what
+ * that guard exists to prevent. Those propagate.
+ *
+ * A non-zero exit caused by an auth or network problem is still read as
+ * absent — docker reports it the same way it reports an unknown manifest, and
+ * telling them apart means matching stderr text that shifts between versions.
+ */
+export declare function imageTagExists(run: RunCommand, imageRepository: string, tag: string): Promise<boolean>;
+/**
+ * The Build workflow's resolve step: derive the image set the declared fleet
+ * state (pilot.yaml + cohorts + users) requires, probe the container registry
+ * for each tag, and emit the missing ones as a GitHub Actions build matrix
+ * (`images_json`, entries `{tag, brain_version, site_packages}`). Dispatch
+ * inputs `BRAIN_VERSION_INPUT`/`SITE_PACKAGES_INPUT` force a single explicit
+ * build instead. Deriving and probing here means a config push builds exactly
+ * what it declares — nothing reactive, nothing manual.
+ */
+export declare function runResolveMissingImages(options: RunResolveMissingImagesOptions): Promise<RequiredImage[]>;

package/dist/index.d.ts

@@ -1,8 +1,11 @@
 export { initPilotRepo } from "./init";
 export { loadPilotRegistry, type LoadPilotRegistryOptions, } from "./load-registry";
+export { runtimeImageTag, sitePackagesFor, requiredImages, resolveImageBuilds, runResolveMissingImages, type ImageRequirementSource, type RequiredImage, type ResolveImageBuildsOptions, type RunResolveMissingImagesOptions, } from "./images";
+export { derivePreviewDomain, type PreviewDomainOptions, } from "./preview-domain";
 export { writeUsersTable } from "./render-users-table";
 export { onboardUser } from "./onboard-user";
 export { addPilotUser } from "./user-add";
+export { assertPilotUsersRemoved, createPilotOffboardDriver, offboardPilotUsers, type OffboardPilotUserPlan, type OffboardPilotUsersOptions, type OffboardPilotUsersResult, type PilotOffboardDnsRecord, type PilotOffboardDriver, type PilotOffboardInspection, type PilotOffboardServer, type PilotOffboardTarget, } from "./user-offboard";
 export { reconcileCohort } from "./reconcile-cohort";
 export { reconcileAll } from "./reconcile-all";
 export { parseArgs, type ParsedArgs } from "./parse-args";
@@ -11,4 +14,9 @@ export { bootstrapPilotSshKey, runPilotSshKeyBootstrap, } from "./ssh-key-bootst
 export { bootstrapPilotOriginCertificate, runPilotCertBootstrap, } from "./cert-bootstrap";
 export { encryptPilotSecrets } from "./secrets-encrypt";
 export { pushPilotSecrets } from "./secrets-push";
+export { verifyPilotUser } from "./verify-user";
+export { assertDirectorySyncStressTarget, directorySyncStressPlanSchema, directorySyncStressProfileSchema, directorySyncStressReportSchema, resolveDirectorySyncStressPlan, runDirectorySyncStressPlan, sampleStressHealth, stressMetricsFailure, type DirectorySyncStressDriver, type DirectorySyncStressPhase, type DirectorySyncStressPlan, type DirectorySyncStressProfile, type DirectorySyncStressReport, } from "./directory-sync-stress";
+export { cleanupDirectorySyncStress, runDeployedDirectorySyncStress, verifyDirectorySyncStressAccess, type CleanupDirectorySyncStressOptions, type CleanupDirectorySyncStressResult, type DeployedDirectorySyncStressOptions, type DeployedDirectorySyncStressResult, type VerifyDirectorySyncStressAccessOptions, type VerifyDirectorySyncStressAccessResult, } from "./directory-sync-stress-system";
+export { assertHealthWatchdogSmokeTarget, cleanupHealthWatchdogSmoke, renderHealthWatchdogSmokeRemoteScript, runHealthWatchdogSmoke, type CleanupHealthWatchdogSmokeOptions, type CleanupHealthWatchdogSmokeResult, type HealthWatchdogSmokeOptions, type HealthWatchdogSmokeResult, type HealthWatchdogSmokeTarget, } from "./health-watchdog-smoke";
 export { runCommand, type CommandResult } from "./run-command";
+export { pilotSchema, cohortSchema, canonicalBundleIdSchema, CAPABILITY_BUNDLE_CONTRACT, type PilotConfig, type CohortConfig, } from "./schema";