@forgezero/agent 0.1.63 → 0.1.65

package/dist/metal-bootstrap.js

@@ -292,7 +292,7 @@ function systemdAgentEgressDirectives(loopbackTcpPorts = []) {
 }
 
 // src/version.ts
-var VERSION = "0.1.63";
+var VERSION = "0.1.65";
 
 // src/otel-collector.ts
 var FORGEZERO_OTEL_COLLECTOR_UNIT = "forgezero-otel-collector.service";

package/dist/operator-bootstrap.d.ts

@@ -25,6 +25,34 @@ export interface OperatorMetalBootstrapRequest {
         sshPublicKeyFiles: string[];
     };
 }
+export interface OperatorPlatformBootstrapFleetRequest {
+    kind: 'platform-fleet-remote';
+    requests: readonly [string, string, string];
+}
+export interface OperatorPlatformBootstrapFleetPlan {
+    kind: 'platform-fleet-remote';
+    mode: OperatorPlatformBootstrapMode;
+    mutation: boolean;
+    environment: PlatformGenesisEnvironment;
+    nodes: readonly {
+        computeReference: string;
+        address: string;
+        via?: string;
+    }[];
+    secretInputs: readonly string[];
+}
+export interface OperatorPlatformBootstrapFleetOutcome {
+    computeReference: string;
+    address: string;
+    ok: boolean;
+    output?: string;
+    error?: string;
+}
+export interface OperatorPlatformBootstrapFleetResult {
+    plan: OperatorPlatformBootstrapFleetPlan;
+    ok: boolean;
+    outcomes: readonly OperatorPlatformBootstrapFleetOutcome[];
+}
 export type OperatorPlatformBootstrapMode = 'apply' | 'status';
 export type OperatorMetalBootstrapMode = 'apply' | 'genesis' | 'rehearsal' | 'rehearsal-cleanup' | 'status';
 export interface OperatorPlatformBootstrapPlan {
@@ -68,10 +96,16 @@ export interface OperatorPlatformBootstrapOptions {
     fzAgentPath?: string;
     fzGitSshPath?: string;
 }
+export declare function createOperatorSshHop(input: Omit<OperatorSshHop, 'hostKeySha256'>): OperatorSshHop;
 export declare function readOperatorPlatformBootstrapRequest(path: string): OperatorPlatformBootstrapRequest;
+export declare function writeOperatorPlatformBootstrapRequest(path: string, request: OperatorPlatformBootstrapRequest): string;
+export declare function readOperatorPlatformBootstrapFleetRequest(path: string): OperatorPlatformBootstrapFleetRequest;
+export declare function writeOperatorPlatformBootstrapFleetRequest(path: string, requestFiles: readonly [string, string, string]): string;
 export declare function readOperatorMetalBootstrapRequest(path: string): OperatorMetalBootstrapRequest;
+export declare function writeOperatorMetalBootstrapRequest(path: string, request: OperatorMetalBootstrapRequest): string;
 export declare function planOperatorMetalBootstrap(request: OperatorMetalBootstrapRequest, mode: OperatorMetalBootstrapMode): OperatorMetalBootstrapPlan;
 export declare function planOperatorPlatformBootstrap(request: OperatorPlatformBootstrapRequest, mode: OperatorPlatformBootstrapMode): OperatorPlatformBootstrapPlan;
+export declare function planOperatorPlatformFleetBootstrap(fleet: OperatorPlatformBootstrapFleetRequest, mode: OperatorPlatformBootstrapMode): OperatorPlatformBootstrapFleetPlan;
 /**
  * Run one reviewed operator action. No private SSH key, credential value or
  * management token is placed in argv; OpenSSH selects the matching private key
@@ -83,6 +117,14 @@ export declare function applyOperatorPlatformBootstrap(request: OperatorPlatform
     plan: OperatorPlatformBootstrapPlan;
     output: string;
 }>;
+/**
+ * Run the exact three-node genesis fleet from one attended secret collection.
+ * Every request is fully validated before the first SSH connection. Nodes run
+ * concurrently because the three-member Agency cannot form sequentially.
+ */
+export declare function applyOperatorPlatformFleetBootstrap(fleet: OperatorPlatformBootstrapFleetRequest, mode: OperatorPlatformBootstrapMode, options?: OperatorPlatformBootstrapOptions & {
+    secrets?: PlatformBootstrapSecrets;
+}): Promise<OperatorPlatformBootstrapFleetResult>;
 /**
  * Install/bootstrap one blank metal host or provision its exact three-node
  * platform seed through the same pinned SSH transport used for guest bootstrap.

package/dist/operator-bootstrap.js

@@ -1396,7 +1396,7 @@ var UPDATE_RETRY_BASE_MS = 5 * 60000;
 var UPDATE_RETRY_MAX_MS = 24 * 60 * 60000;
 
 // src/version.ts
-var VERSION = "0.1.63";
+var VERSION = "0.1.65";
 
 // src/software.ts
 var PINNED_BUN_VERSION = "1.3.14";
@@ -2045,17 +2045,16 @@ function agentUnit(options) {
   if (Boolean(options.pullMigrations) !== Boolean(options.lifecycleProfilePath)) {
     throw new Error("migration pull and lifecycle profile must be supplied together");
   }
-  const bootstrapEnabled = Boolean(options.pullBootstrap && options.bootstrapSshCredentialPath && options.bootstrapSshPublicKeyPath && options.bootstrapTargetTelemetryEndpoint);
-  if ([
-    options.pullBootstrap,
-    options.bootstrapSshCredentialPath,
-    options.bootstrapSshPublicKeyPath,
-    options.bootstrapTargetTelemetryEndpoint
-  ].some(Boolean) && !bootstrapEnabled) {
-    throw new Error("bootstrap pull, SSH credential, public key and target telemetry endpoint must be supplied together");
+  const bootstrapIdentityEnabled = Boolean(options.bootstrapSshCredentialPath && options.bootstrapSshPublicKeyPath);
+  if (Boolean(options.bootstrapSshCredentialPath) !== Boolean(options.bootstrapSshPublicKeyPath)) {
+    throw new Error("bootstrap SSH credential and public key paths must be supplied together");
+  }
+  const bootstrapEnabled = Boolean(options.pullBootstrap);
+  if (bootstrapEnabled && (!bootstrapIdentityEnabled || !options.bootstrapTargetTelemetryEndpoint) || !bootstrapEnabled && options.bootstrapTargetTelemetryEndpoint) {
+    throw new Error("bootstrap pull, SSH identity and target telemetry endpoint must be supplied together");
   }
   const lifecycleHelperSocketPath = lifecycleEnabled ? systemdPath(options.lifecycleHelperSocketPath ?? LIFECYCLE_HELPER_SOCKET, "lifecycle helper socket") : undefined;
-  const bootstrapSshCredentialPath = bootstrapEnabled ? systemdPath(options.bootstrapSshCredentialPath, "bootstrap SSH credential") : undefined;
+  const bootstrapSshCredentialPath = bootstrapIdentityEnabled ? systemdPath(options.bootstrapSshCredentialPath, "bootstrap SSH credential") : undefined;
   const warpValues = [
     options.warpOrganization,
     options.warpClientIdCredentialPath,
@@ -2294,15 +2293,13 @@ function planProvision(options) {
   if (Boolean(options.pullMigrations) !== Boolean(options.lifecycleProfilePath)) {
     throw new Error("migration pull and lifecycle profile must be supplied together");
   }
-  const bootstrapEnabled = Boolean(options.pullBootstrap && options.bootstrapSshCredentialPath && options.bootstrapSshPublicKeyPath && options.bootstrapTargetTelemetryEndpoint);
-  if ([
-    options.pullBootstrap,
-    options.bootstrapSshCredentialPath,
-    options.bootstrapSshPublicKeyPath,
-    options.bootstrapSshSourcePath,
-    options.bootstrapTargetTelemetryEndpoint
-  ].some(Boolean) && !bootstrapEnabled) {
-    throw new Error("bootstrap pull, SSH credential, public key and target telemetry endpoint must be supplied together");
+  const bootstrapIdentityEnabled = Boolean(options.bootstrapSshCredentialPath && options.bootstrapSshPublicKeyPath);
+  if (Boolean(options.bootstrapSshCredentialPath) !== Boolean(options.bootstrapSshPublicKeyPath) || options.bootstrapSshSourcePath && !bootstrapIdentityEnabled) {
+    throw new Error("bootstrap SSH credential and public key paths must be supplied together");
+  }
+  const bootstrapEnabled = Boolean(options.pullBootstrap);
+  if (bootstrapEnabled && (!bootstrapIdentityEnabled || !options.bootstrapTargetTelemetryEndpoint) || !bootstrapEnabled && options.bootstrapTargetTelemetryEndpoint) {
+    throw new Error("bootstrap pull, SSH identity and target telemetry endpoint must be supplied together");
   }
   const warpValues = [
     options.warpOrganization,
@@ -2312,13 +2309,13 @@ function planProvision(options) {
   const warpEnabled = warpValues.every(Boolean);
   if (warpValues.some(Boolean) && !warpEnabled)
     throw new Error("WARP configuration must be supplied together");
-  const enrolmentEnabled = Boolean(options.enrolTokenCredentialPath && options.enrolStatePath);
-  if (Boolean(options.enrolTokenCredentialPath) !== Boolean(options.enrolStatePath) || options.enrolTokenSourcePath && !enrolmentEnabled) {
-    throw new Error("direct enrolment credential and state paths must be supplied together");
+  const enrolmentEnabled = Boolean(options.enrolTokenCredentialPath);
+  if (options.enrolTokenCredentialPath && !options.enrolStatePath || options.enrolTokenSourcePath && (!options.enrolTokenCredentialPath || !options.enrolStatePath)) {
+    throw new Error("direct enrolment credential requires its durable state path");
   }
   const enrolTokenSourcePath = options.enrolTokenSourcePath ? systemdPath(options.enrolTokenSourcePath, "enrolment source") : undefined;
   const enrolTokenCredentialPath = enrolmentEnabled ? systemdPath(options.enrolTokenCredentialPath, "enrolment credential") : undefined;
-  const enrolStatePath = enrolmentEnabled ? systemdPath(options.enrolStatePath, "enrolment state") : undefined;
+  const enrolStatePath = options.enrolStatePath ? systemdPath(options.enrolStatePath, "enrolment state") : undefined;
   const enrolStateDir = enrolStatePath?.replace(/\/[^/]+$/, "");
   const sourceBinPath = options.sourceBinPath ? systemdPath(options.sourceBinPath, "agent source binary") : undefined;
   const binPath = options.binPath ? systemdPath(options.binPath, "agent binary") : undefined;
@@ -2330,8 +2327,8 @@ function planProvision(options) {
   const gitPublicKeyDir = gitPublicKeyPath?.replace(/\/[^/]+$/, "");
   const lifecycleProfilePath = lifecycleEnabled ? systemdPath(options.lifecycleProfilePath, "lifecycle profile") : undefined;
   const lifecycleHelperSocketPath = lifecycleEnabled ? systemdPath(options.lifecycleHelperSocketPath ?? LIFECYCLE_HELPER_SOCKET, "lifecycle helper socket") : undefined;
-  const bootstrapSshCredentialPath = bootstrapEnabled ? systemdPath(options.bootstrapSshCredentialPath, "bootstrap SSH credential") : undefined;
-  const bootstrapSshPublicKeyPath = bootstrapEnabled ? systemdPath(options.bootstrapSshPublicKeyPath, "bootstrap SSH public key") : undefined;
+  const bootstrapSshCredentialPath = bootstrapIdentityEnabled ? systemdPath(options.bootstrapSshCredentialPath, "bootstrap SSH credential") : undefined;
+  const bootstrapSshPublicKeyPath = bootstrapIdentityEnabled ? systemdPath(options.bootstrapSshPublicKeyPath, "bootstrap SSH public key") : undefined;
   const bootstrapSshSourcePath = options.bootstrapSshSourcePath ? systemdPath(options.bootstrapSshSourcePath, "bootstrap SSH private-key source") : undefined;
   const bootstrapSshPublicKeyDir = bootstrapSshPublicKeyPath?.replace(/\/[^/]+$/, "");
   const warpClientIdCredentialPath = warpEnabled ? systemdPath(options.warpClientIdCredentialPath, "WARP client-id credential") : undefined;
@@ -2431,7 +2428,7 @@ function planProvision(options) {
         step("Git deploy identity directory", { kind: "directories", directories: [{ path: gitPublicKeyDir, mode: 493, owner: "root", group: "root" }] }),
         step("unique encrypted Git deploy identity", { kind: "ensure-git-identity", credential: gitCredentialPath, publicKey: gitPublicKeyPath })
       ] : [],
-      ...bootstrapEnabled ? [
+      ...bootstrapIdentityEnabled ? [
         step("bootstrap SSH public identity directory", { kind: "directories", directories: [
           { path: bootstrapSshPublicKeyDir, mode: 493, owner: "root", group: "root" }
         ] }),
@@ -2467,6 +2464,10 @@ function planProvision(options) {
         { argv: ["/usr/bin/rm", "-f", "/etc/systemd/system/forgezero-deploy-runner.socket"] },
         { argv: ["/usr/bin/systemctl", "daemon-reload"] }
       ] })] : [],
+      ...enrolStatePath && !enrolmentEnabled ? [step("retire consumed enrolment unit", { kind: "commands", commands: [
+        { argv: ["/usr/bin/systemctl", "disable", "--now", "forgezero-agent-enrol.service"], acceptedExitCodes: [0, 1, 5] },
+        { argv: ["/usr/bin/rm", "-f", ENROLMENT_UNIT_PATH] }
+      ] })] : [],
       step("enable and converge services", { kind: "commands", commands: [
         { argv: ["/usr/bin/systemctl", "enable", ...enabledUnits] },
         { argv: ["/usr/bin/systemctl", "reset-failed", "forgezero-agent.service"], acceptedExitCodes: [0, 1] },
@@ -4181,7 +4182,15 @@ async function applyBootstrap(input, host = localBootstrapHost(), secrets, depen
   if (connectorCapabilities?.meshConnectorToken && !host.exists(WARP_CONNECTOR_CREDENTIAL)) {
     await seal(host, "CF_WARP_CONNECTOR_TOKEN", WARP_CONNECTOR_CREDENTIAL, connectorCapabilities.meshConnectorToken);
   }
-  await host.installAgent(config);
+  if (alreadyEnrolled) {
+    await host.installAgent(config, "bound");
+  } else if (config.kind === "platform") {
+    if (bootstrapManifest)
+      await host.installAgent(config, "bootstrap");
+  } else {
+    await host.installAgent(config, "enrol");
+    await host.installAgent(config, "bound");
+  }
   if (config.kind === "platform" && config.firewall.enabled) {
     await host.ensureSoftware(plan.software.filter(({ id }) => id === "ufw"));
   } else
@@ -4331,7 +4340,19 @@ async function applyBootstrap(input, host = localBootstrapHost(), secrets, depen
 `, 384);
       host.remove(config.bootstrapBundle.bundleFile);
       host.remove(config.bootstrapBundle.manifestFile);
-      await host.installAgent(config);
+    }
+    if (!alreadyEnrolled) {
+      await checked3(host, [
+        "curl",
+        "--fail",
+        "--silent",
+        "--show-error",
+        "--max-time",
+        "10",
+        `http://127.0.0.1:3000${runtime.healthPath}`
+      ], "release-one API health");
+      await host.installAgent(config, "enrol");
+      await host.installAgent(config, "bound");
     }
   }
   if (config.cloudflareHandoff) {
@@ -4500,6 +4521,65 @@ function readBootstrapConfig(path) {
   }
   return validateBootstrapConfig(strictBootstrapDocument(JSON.parse(readFileSync5(path, "utf8"))));
 }
+function planBootstrapAgentInstall(config, phase, context) {
+  const { capabilities, hasBinding, hasEnrolCredential, initialBundle } = context;
+  if (phase === "bootstrap") {
+    if (config.kind !== "platform" || hasBinding || !initialBundle) {
+      throw new Error("release-one Agent install requires an unbound platform host and verified bootstrap bundle");
+    }
+  } else if (phase === "enrol") {
+    if (hasBinding || !hasEnrolCredential) {
+      throw new Error("Agent enrolment requires one unbound host and its sealed one-use credential");
+    }
+  } else if (!hasBinding) {
+    throw new Error("bound Agent convergence requires durable enrolment state");
+  }
+  const bound = phase === "bound";
+  const enrolling = phase === "enrol";
+  const authenticated = enrolling || bound;
+  const bootstrapRunner = platformBootstrapRunner(config) || config.kind === "enrolled-compute" && Boolean(config.bootstrapRunner);
+  const options = {
+    capabilities,
+    socketPath: DEFAULT_SOCKET2,
+    seedPath: "/var/lib/forgezero/node.seed",
+    controlSocketPath: CONTROL_SOCKET,
+    repository: phase === "bootstrap" ? initialBundle.path : bound && config.kind === "enrolled-compute" ? config.repository : undefined,
+    branch: phase === "bootstrap" ? initialBundle.manifest.branch : bound && config.kind === "enrolled-compute" ? config.branch : undefined,
+    bootstrapBundlePath: phase === "bootstrap" ? initialBundle.path : undefined,
+    bootstrapBundleManifestPath: phase === "bootstrap" ? initialBundle.manifestPath : undefined,
+    profile: config.profile,
+    deployRoot: config.deployRoot ?? "/opt/forgezero",
+    deploymentCredentials: config.deploymentCredentials,
+    publicApiUrl: config.apiUrl,
+    gitCredentialPath: authenticated && config.kind === "enrolled-compute" && config.gitDeployKey ? "/etc/forgezero/creds/git-deploy-key.cred" : undefined,
+    gitPublicKeyPath: authenticated && config.kind === "enrolled-compute" && config.gitDeployKey ? "/etc/forgezero/git/deploy.pub" : undefined,
+    generateGitIdentity: authenticated && config.kind === "enrolled-compute" && config.gitDeployKey === true,
+    pullDeployments: bound,
+    pullMigrations: bound && config.kind === "platform",
+    pullBootstrap: bound && bootstrapRunner,
+    bootstrapSshCredentialPath: authenticated && bootstrapRunner ? BOOTSTRAP_SSH_CREDENTIAL : undefined,
+    bootstrapSshSourcePath: enrolling && config.kind === "enrolled-compute" ? config.bootstrapRunner?.sshPrivateKeyFile : undefined,
+    bootstrapSshPublicKeyPath: authenticated && bootstrapRunner ? BOOTSTRAP_SSH_PUBLIC_KEY : undefined,
+    bootstrapTargetTelemetryEndpoint: bound && bootstrapRunner ? platformBootstrapRunner(config) ? config.telemetryEndpoint : config.kind === "enrolled-compute" ? config.bootstrapRunner?.targetTelemetryEndpoint : undefined : undefined,
+    lifecycleProfilePath: bound && config.kind === "platform" ? LIFECYCLE_PROFILE : undefined,
+    enforceEgress: true,
+    nodeHostname: config.nodeHostname,
+    telemetryEndpoint: config.telemetryEndpoint,
+    binPath: "/usr/local/lib/forgezero/agent/fz-agent",
+    sourceBinPath: PACKAGED_AGENT_BIN,
+    ...enrolling ? {
+      enrolTokenCredentialPath: ENROL_CREDENTIAL,
+      enrolStatePath: "/var/lib/forgezero/enrolment.json"
+    } : bound ? { enrolStatePath: "/var/lib/forgezero/enrolment.json" } : {},
+    ...authenticated ? {
+      apiUrl: config.apiUrl,
+      project: config.kind === "enrolled-compute" ? config.realm : "platform",
+      environment: config.kind === "enrolled-compute" ? undefined : config.environment,
+      nodeLabel: config.kind === "enrolled-compute" ? config.nodeHostname : config.computeReference
+    } : {}
+  };
+  return planInstall(options);
+}
 function localBootstrapHost() {
   const execute = async (argv, options = {}) => {
     const child = Bun.spawn([...argv], { stdin: options.stdin === undefined ? "ignore" : "pipe", stdout: "pipe", stderr: "pipe" });
@@ -4547,10 +4627,10 @@ function localBootstrapHost() {
         throw new Error(`Agent software requirements failed: ${result.output.trim()}`);
       return result;
     },
-    async installAgent(config) {
+    async installAgent(config, phase) {
       const capabilities = await readCapabilities(localRunner);
-      const deployRoot = config.deployRoot ?? "/opt/forgezero";
       const hasBinding = existsSync5("/var/lib/forgezero/enrolment.json");
+      const hasEnrolCredential = existsSync5(ENROL_CREDENTIAL);
       const initialBundle = config.kind === "platform" && !existsSync5(BOOTSTRAP_RELEASE_EVIDENCE) ? {
         path: config.bootstrapBundle.bundleFile,
         manifestPath: config.bootstrapBundle.manifestFile,
@@ -4571,45 +4651,11 @@ function localBootstrapHost() {
         writeFileSync5(LIFECYCLE_PROFILE, `${JSON.stringify(lifecycle, null, 2)}
 `, { mode: 256 });
       }
-      const plan = planInstall({
+      const plan = planBootstrapAgentInstall(config, phase, {
         capabilities,
-        socketPath: DEFAULT_SOCKET2,
-        seedPath: "/var/lib/forgezero/node.seed",
-        controlSocketPath: "/run/forgezero/control.sock",
-        repository: initialBundle?.path ?? (config.kind === "enrolled-compute" ? config.repository : undefined),
-        branch: initialBundle?.manifest.branch ?? (config.kind === "enrolled-compute" ? config.branch : undefined),
-        bootstrapBundlePath: initialBundle?.path,
-        bootstrapBundleManifestPath: initialBundle?.manifestPath,
-        profile: config.kind === "platform" ? config.profile : config.profile,
-        deployRoot,
-        deploymentCredentials: config.deploymentCredentials,
-        publicApiUrl: config.apiUrl,
-        gitCredentialPath: config.kind === "enrolled-compute" && config.gitDeployKey ? "/etc/forgezero/creds/git-deploy-key.cred" : undefined,
-        gitPublicKeyPath: config.kind === "enrolled-compute" && config.gitDeployKey ? "/etc/forgezero/git/deploy.pub" : undefined,
-        generateGitIdentity: config.kind === "enrolled-compute" && config.gitDeployKey === true,
-        pullDeployments: hasBinding,
-        pullMigrations: config.kind === "platform" && hasBinding,
-        pullBootstrap: platformBootstrapRunner(config) || config.kind === "enrolled-compute" && Boolean(config.bootstrapRunner),
-        bootstrapSshCredentialPath: platformBootstrapRunner(config) || config.kind === "enrolled-compute" && config.bootstrapRunner ? BOOTSTRAP_SSH_CREDENTIAL : undefined,
-        bootstrapSshSourcePath: config.kind === "enrolled-compute" ? config.bootstrapRunner?.sshPrivateKeyFile : undefined,
-        bootstrapSshPublicKeyPath: platformBootstrapRunner(config) || config.kind === "enrolled-compute" && config.bootstrapRunner ? BOOTSTRAP_SSH_PUBLIC_KEY : undefined,
-        bootstrapTargetTelemetryEndpoint: platformBootstrapRunner(config) ? config.telemetryEndpoint : config.kind === "enrolled-compute" ? config.bootstrapRunner?.targetTelemetryEndpoint : undefined,
-        lifecycleProfilePath: config.kind === "platform" ? LIFECYCLE_PROFILE : undefined,
-        enforceEgress: true,
-        nodeHostname: config.nodeHostname,
-        telemetryEndpoint: config.telemetryEndpoint,
-        binPath: "/usr/local/lib/forgezero/agent/fz-agent",
-        sourceBinPath: PACKAGED_AGENT_BIN,
-        ...existsSync5(ENROL_CREDENTIAL) || hasBinding ? {
-          enrolTokenCredentialPath: existsSync5(ENROL_CREDENTIAL) ? ENROL_CREDENTIAL : undefined,
-          enrolStatePath: "/var/lib/forgezero/enrolment.json"
-        } : {},
-        ...hasBinding ? {
-          apiUrl: config.apiUrl,
-          project: config.kind === "enrolled-compute" ? config.realm : "platform",
-          environment: config.kind === "enrolled-compute" ? undefined : config.environment,
-          nodeLabel: config.kind === "enrolled-compute" ? config.nodeHostname : config.computeReference
-        } : {}
+        hasBinding,
+        hasEnrolCredential,
+        initialBundle
       });
       for (const unit of [{ path: plan.unitPath, unit: plan.unit }, ...plan.auxiliaryUnits]) {
         mkdirSync5(dirname6(unit.path), { recursive: true, mode: 493 });
@@ -5525,10 +5571,10 @@ async function metalBootstrapStatus(exec = defaultExec2) {
 
 // src/operator-bootstrap.ts
 import { createHash as createHash4, randomBytes as randomBytes5 } from "crypto";
-import { lstatSync as lstatSync5, mkdtempSync, readFileSync as readFileSync7, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "fs";
+import { chmodSync as chmodSync5, lstatSync as lstatSync5, mkdirSync as mkdirSync8, mkdtempSync, readFileSync as readFileSync7, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "fs";
 import { isIP as isIP6 } from "net";
 import { tmpdir } from "os";
-import { basename, join as join6 } from "path";
+import { basename, dirname as dirname9, isAbsolute as isAbsolute4, join as join6, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/platform-genesis.ts
@@ -5663,6 +5709,25 @@ var exactKeys3 = (value, keys, label) => {
     throw new Error(`${label} contains unknown fields: ${unknown.join(", ")}`);
   return record;
 };
+var canonicalOutputPath = (path, label) => {
+  if (!isAbsolute4(path) || resolve6(path) !== path || /[\r\n\0]/.test(path)) {
+    throw new Error(`${label} must be a canonical absolute path`);
+  }
+  return path;
+};
+var writeOwnerJson2 = (path, value, label) => {
+  canonicalOutputPath(path, label);
+  mkdirSync8(dirname9(path), { recursive: true, mode: 448 });
+  const parent = lstatSync5(dirname9(path));
+  const uid = process.getuid?.() ?? parent.uid;
+  if (!parent.isDirectory() || parent.isSymbolicLink() || parent.uid !== uid || (parent.mode & 63) !== 0) {
+    throw new Error(`${label} parent must be an owner-only directory`);
+  }
+  writeFileSync8(path, `${JSON.stringify(value, null, 2)}
+`, { mode: 384, flag: "wx" });
+  chmodSync5(path, 384);
+  return path;
+};
 var ownerFile = (path, limit, label) => {
   if (!path.startsWith("/") || /[\r\n]/.test(path))
     throw new Error(`${label} path must be absolute`);
@@ -5721,8 +5786,10 @@ var validateHop = (value, label) => {
   }
   return hop;
 };
-function readOperatorPlatformBootstrapRequest(path) {
-  const value = JSON.parse(new TextDecoder().decode(ownerFile(path, REQUEST_LIMIT, "operator bootstrap request")));
+function createOperatorSshHop(input) {
+  return validateHop({ ...input, hostKeySha256: fingerprint(input.hostKey) }, "operator SSH hop");
+}
+var validatePlatformRequestValue = (value) => {
   const root = exactKeys3(value, ["kind", "target", "platformConfigFile"], "operator bootstrap request");
   if (root.kind !== "platform-remote")
     throw new Error("operator bootstrap kind must be platform-remote");
@@ -5741,6 +5808,7 @@ function readOperatorPlatformBootstrapRequest(path) {
   socketPath(targetValue.agentSocket);
   if (typeof root.platformConfigFile !== "string")
     throw new Error("platformConfigFile must be an absolute path");
+  canonicalOutputPath(root.platformConfigFile, "platformConfigFile");
   const config = readBootstrapConfig(root.platformConfigFile);
   if (config.kind !== "platform")
     throw new Error("operator bootstrap requires a platform config");
@@ -5754,9 +5822,39 @@ function readOperatorPlatformBootstrapRequest(path) {
       ...targetValue.jump === undefined ? {} : { jump: validateHop(targetValue.jump, "operator bootstrap jump") }
     }
   };
-}
-function readOperatorMetalBootstrapRequest(path) {
-  const value = JSON.parse(new TextDecoder().decode(ownerFile(path, REQUEST_LIMIT, "operator metal request")));
+};
+function readOperatorPlatformBootstrapRequest(path) {
+  const value = JSON.parse(new TextDecoder().decode(ownerFile(path, REQUEST_LIMIT, "operator bootstrap request")));
+  return validatePlatformRequestValue(value);
+}
+function writeOperatorPlatformBootstrapRequest(path, request) {
+  validatePlatformRequestValue(request);
+  return writeOwnerJson2(path, request, "operator bootstrap request");
+}
+function readOperatorPlatformBootstrapFleetRequest(path) {
+  const value = JSON.parse(new TextDecoder().decode(ownerFile(path, REQUEST_LIMIT, "operator fleet request")));
+  const root = exactKeys3(value, ["kind", "requests"], "operator fleet request");
+  if (root.kind !== "platform-fleet-remote")
+    throw new Error("operator fleet kind must be platform-fleet-remote");
+  if (!Array.isArray(root.requests) || root.requests.length !== 3 || root.requests.some((entry) => typeof entry !== "string")) {
+    throw new Error("operator fleet requires exactly three request files");
+  }
+  const requests = root.requests.map((entry) => canonicalOutputPath(entry, "operator fleet request file"));
+  if (new Set(requests).size !== 3)
+    throw new Error("operator fleet request files must be unique");
+  for (const request of requests)
+    readOperatorPlatformBootstrapRequest(request);
+  return { kind: "platform-fleet-remote", requests };
+}
+function writeOperatorPlatformBootstrapFleetRequest(path, requestFiles) {
+  const request = { kind: "platform-fleet-remote", requests: requestFiles };
+  if (new Set(requestFiles).size !== 3)
+    throw new Error("operator fleet request files must be unique");
+  for (const file of requestFiles)
+    readOperatorPlatformBootstrapRequest(file);
+  return writeOwnerJson2(path, request, "operator fleet request");
+}
+var validateMetalRequestValue = (value) => {
   const root = exactKeys3(value, ["kind", "target", "metalConfigFile", "genesis"], "operator metal request");
   if (root.kind !== "metal-remote")
     throw new Error("operator metal bootstrap kind must be metal-remote");
@@ -5775,6 +5873,7 @@ function readOperatorMetalBootstrapRequest(path) {
   socketPath(targetValue.agentSocket);
   if (typeof root.metalConfigFile !== "string")
     throw new Error("metalConfigFile must be an absolute path");
+  canonicalOutputPath(root.metalConfigFile, "metalConfigFile");
   readMetalBootstrapConfig(root.metalConfigFile);
   const genesis = exactKeys3(root.genesis, ["environment", "sshPublicKeyFiles"], "operator metal genesis");
   if (typeof genesis.environment !== "string" || !PLATFORM_GENESIS_ENVIRONMENTS.includes(genesis.environment)) {
@@ -5798,6 +5897,14 @@ function readOperatorMetalBootstrapRequest(path) {
       sshPublicKeyFiles: genesis.sshPublicKeyFiles
     }
   };
+};
+function readOperatorMetalBootstrapRequest(path) {
+  const value = JSON.parse(new TextDecoder().decode(ownerFile(path, REQUEST_LIMIT, "operator metal request")));
+  return validateMetalRequestValue(value);
+}
+function writeOperatorMetalBootstrapRequest(path, request) {
+  validateMetalRequestValue(request);
+  return writeOwnerJson2(path, request, "operator metal request");
 }
 function planOperatorMetalBootstrap(request, mode) {
   const config = readMetalBootstrapConfig(request.metalConfigFile);
@@ -5857,6 +5964,87 @@ function planOperatorPlatformBootstrap(request, mode) {
     secretInputs: mode === "apply" ? [...attendedSecretNames(config), ...secretSources(config).map(([name]) => name)] : []
   };
 }
+var fleetConfigIdentity = (config) => {
+  const normalized = structuredClone(config);
+  delete normalized.computeReference;
+  delete normalized.nodeHostname;
+  delete normalized.cloudflareHandoff;
+  delete normalized.database.role;
+  delete normalized.database.address;
+  delete normalized.database.master;
+  const environment = normalized.runtime.environment;
+  delete environment.databaseRole;
+  delete environment.databaseAddress;
+  delete environment.databaseMaster;
+  delete environment.nodeHostname;
+  delete environment.seedSyncPeers;
+  delete environment.custodianEmail;
+  return JSON.stringify(normalized);
+};
+function validatedPlatformFleet(fleet) {
+  const requests = fleet.requests.map(readOperatorPlatformBootstrapRequest);
+  const configs = requests.map((request) => {
+    const config = readBootstrapConfig(request.platformConfigFile);
+    if (config.kind !== "platform")
+      throw new Error("operator fleet requires platform configs");
+    return config;
+  });
+  const environment = configs[0].environment;
+  const expected = PLATFORM_GENESIS_FLEETS[environment];
+  if (!expected || expected.length !== 3)
+    throw new Error("operator fleet environment is invalid");
+  const identity = fleetConfigIdentity(configs[0]);
+  const operatorIdentity = `${requests[0].target.identityPublicKeyFile}\x00${requests[0].target.agentSocket}`;
+  const jumpIdentity = JSON.stringify(requests[0].target.jump ?? null);
+  const coordinators = expected.map((guest) => `http://${guest.address}:8529`);
+  const nodeHostnames = new Set;
+  for (let index = 0;index < 3; index += 1) {
+    const config = configs[index];
+    const request = requests[index];
+    const guest = expected[index];
+    const role = index === 0 ? "master" : "joiner";
+    if (config.environment !== environment || fleetConfigIdentity(config) !== identity) {
+      throw new Error("operator fleet platform configs do not share one immutable identity");
+    }
+    if (config.computeReference !== guest.name || config.database.address !== guest.address || config.database.role !== role || config.database.agency !== "member" || (role === "master" ? config.database.master !== undefined : config.database.master !== expected[0].address) || config.database.coordinators.join(",") !== coordinators.join(",") || config.enrolment.source !== "genesis-derived" || config.cloudflareHandoff?.nodeName !== guest.name) {
+      throw new Error(`operator fleet ${guest.name} does not match the exact genesis topology`);
+    }
+    if (request.target.address !== guest.address || request.target.port !== 22 || request.target.user !== "forgezero") {
+      throw new Error(`operator fleet ${guest.name} SSH target must be forgezero@${guest.address}:22`);
+    }
+    if (`${request.target.identityPublicKeyFile}\x00${request.target.agentSocket}` !== operatorIdentity) {
+      throw new Error("operator fleet must use one caller-approved SSH identity and agent socket");
+    }
+    if (JSON.stringify(request.target.jump ?? null) !== jumpIdentity) {
+      throw new Error("operator fleet must use one pinned Metal jump or no jump on every node");
+    }
+    if (nodeHostnames.has(config.nodeHostname))
+      throw new Error("operator fleet node hostnames must be unique");
+    nodeHostnames.add(config.nodeHostname);
+  }
+  return { requests, configs, environment };
+}
+function planOperatorPlatformFleetBootstrap(fleet, mode) {
+  const { requests, configs, environment } = validatedPlatformFleet(fleet);
+  const secretInputs = mode === "apply" ? attendedSecretNames(configs[0]) : [];
+  for (const config of configs.slice(1)) {
+    if (JSON.stringify(attendedSecretNames(config)) !== JSON.stringify(secretInputs)) {
+      throw new Error("operator fleet configs do not share one attended secret schema");
+    }
+  }
+  return {
+    kind: "platform-fleet-remote",
+    mode,
+    mutation: mode !== "status",
+    environment,
+    nodes: requests.map((request, index) => ({
+      computeReference: configs[index].computeReference,
+      address: request.target.address,
+      ...request.target.jump ? { via: request.target.jump.address } : {}
+    })),
+    secretInputs
+  };
+}
 var defaultExec3 = async (argv, options = {}) => {
   const child = Bun.spawn([...argv], {
     stdin: options.stdin === undefined ? "ignore" : "pipe",
@@ -6099,6 +6287,30 @@ async function applyOperatorPlatformBootstrap(request, mode, options = {}) {
     rmSync6(directory, { recursive: true, force: true });
   }
 }
+async function applyOperatorPlatformFleetBootstrap(fleet, mode, options = {}) {
+  const plan = planOperatorPlatformFleetBootstrap(fleet, mode);
+  const { requests, configs } = validatedPlatformFleet(fleet);
+  const secrets = mode === "apply" ? validatePlatformBootstrapSecrets(configs[0], options.secrets) : undefined;
+  if (secrets) {
+    for (const config of configs.slice(1))
+      validatePlatformBootstrapSecrets(config, secrets);
+  }
+  const settled = await Promise.allSettled(requests.map((request) => applyOperatorPlatformBootstrap(request, mode, { ...options, secrets })));
+  const outcomes = settled.map((result, index) => {
+    const config = configs[index];
+    const address = requests[index].target.address;
+    if (result.status === "fulfilled")
+      return {
+        computeReference: config.computeReference,
+        address,
+        ok: true,
+        output: result.value.output.slice(0, 65536)
+      };
+    const message = result.reason instanceof Error ? result.reason.message : String(result.reason);
+    return { computeReference: config.computeReference, address, ok: false, error: message.slice(0, 4096) };
+  });
+  return { plan, ok: outcomes.every(({ ok }) => ok), outcomes };
+}
 async function applyOperatorMetalBootstrap(request, mode, options = {}) {
   const plan = planOperatorMetalBootstrap(request, mode);
   publicIdentity(request.target.identityPublicKeyFile);
@@ -6153,10 +6365,17 @@ async function applyOperatorMetalBootstrap(request, mode, options = {}) {
   }
 }
 export {
+  writeOperatorPlatformBootstrapRequest,
+  writeOperatorPlatformBootstrapFleetRequest,
+  writeOperatorMetalBootstrapRequest,
   readOperatorPlatformBootstrapRequest,
+  readOperatorPlatformBootstrapFleetRequest,
   readOperatorMetalBootstrapRequest,
+  planOperatorPlatformFleetBootstrap,
   planOperatorPlatformBootstrap,
   planOperatorMetalBootstrap,
+  createOperatorSshHop,
+  applyOperatorPlatformFleetBootstrap,
   applyOperatorPlatformBootstrap,
   applyOperatorMetalBootstrap
 };