@botbuddy/cli 1.59.6 → 1.59.8

package/src/daemon/bootstrap.mjs

@@ -0,0 +1,386 @@
+// BOT-2057: public requester orchestration for a genuinely fresh daemon host.
+// The target creates or reads its own P-256 scalar; this module handles only
+// the public SPKI DTO and never receives a private key. There is intentionally
+// no local approval polling loop: host policy wakes only through the pushed
+// BOT-2324 raw wait condition, then this flow re-registers server-side.
+import { createHash } from "node:crypto";
+
+import { DAEMON_PRODUCTION_MCP_SERVER, enrollDaemonDeviceProfileFromBootstrapIdentity } from "./enrollment.mjs";
+import { installRemoteService, installedBinaryPath, stageRemoteDaemonRelease } from "./installer.mjs";
+import {
+  createRemoteBootstrapIdentity,
+  deliverDaemonProfileFromBootstrapIdentityOverSSH,
+  inspectRemoteBootstrapIdentity,
+  verifyRemoteServiceIdentity,
+} from "./profile-delivery.mjs";
+import { validateDaemonRelease } from "./release.mjs";
+import { renderLinuxUnit, renderMacDaemon } from "./service.mjs";
+
+const HOST_KEY_RE = /^bbh-[0-9a-f]{24}$/;
+const ABSOLUTE_PATH_RE = /^\/(?:[A-Za-z0-9._-]+\/)*[A-Za-z0-9._-]+$/;
+const SERVICE_USER_RE = /^[a-z_][a-z0-9_-]*$/i;
+const ENGINE_ID_RE = /^[A-Za-z0-9._:-]{1,200}$/;
+const P256_SPKI_PREFIX = Buffer.from("3059301306072a8648ce3d020106082a8648ce3d030107034200", "hex");
+const DOCKER_APPROVAL_ORIGIN = "https://app.bot-buddy.ai";
+
+export class DaemonBootstrapError extends Error {
+  constructor(code) {
+    super(code);
+    this.name = "DaemonBootstrapError";
+    this.code = code;
+  }
+}
+
+const fail = (code) => { throw new DaemonBootstrapError(code); };
+
+function validPath(value) {
+  return typeof value === "string" && ABSOLUTE_PATH_RE.test(value) && !value.split("/").includes("..");
+}
+
+function exactObject(value, keys) {
+  return value && typeof value === "object" && !Array.isArray(value) &&
+    Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+
+function checkedSpec(spec) {
+  const keys = [
+    "mode", "serverUrl", "sshHost", "serviceUser", "daemonBinary", "profilePath", "requestingHost",
+    "runtimeEngineId", "platform", "arch", "releaseRoot", "home", "config", "approvalTimeoutSeconds",
+  ];
+  const optional = ["caller", "callerHarness", "callerTicket"];
+  if (!spec || typeof spec !== "object" || Array.isArray(spec) ||
+      Object.keys(spec).some((key) => !keys.includes(key) && !optional.includes(key)) ||
+      keys.some((key) => !Object.hasOwn(spec, key))) fail("daemon_bootstrap_spec_invalid");
+  if (
+    !["create", "resume"].includes(spec.mode) || spec.serverUrl !== DAEMON_PRODUCTION_MCP_SERVER ||
+    typeof spec.sshHost !== "string" || !/^(?:[A-Za-z0-9._-]+@)?[A-Za-z0-9._-]+$/.test(spec.sshHost) ||
+    typeof spec.serviceUser !== "string" || spec.serviceUser === "root" || !SERVICE_USER_RE.test(spec.serviceUser) ||
+    !validPath(spec.daemonBinary) || !validPath(spec.profilePath) || !spec.profilePath.endsWith("/profile.json") ||
+    typeof spec.requestingHost !== "string" || !spec.requestingHost || Buffer.byteLength(spec.requestingHost, "utf8") > 80 ||
+    typeof spec.runtimeEngineId !== "string" || !ENGINE_ID_RE.test(spec.runtimeEngineId) ||
+    !["darwin", "linux"].includes(spec.platform) || typeof spec.arch !== "string" || !spec.arch ||
+    !validPath(spec.releaseRoot) || !validPath(spec.home) || !validPath(spec.config) ||
+    !Number.isSafeInteger(spec.approvalTimeoutSeconds) || spec.approvalTimeoutSeconds < 1 || spec.approvalTimeoutSeconds > 3_600 ||
+    optional.some((key) => spec[key] !== undefined && (typeof spec[key] !== "string" || !spec[key]))
+  ) fail("daemon_bootstrap_spec_invalid");
+  return spec;
+}
+
+function checkedIdentity(value) {
+  if (!exactObject(value, ["version", "host_key", "public_key_spki_base64"]) ||
+      value.version !== 1 || typeof value.host_key !== "string" || !HOST_KEY_RE.test(value.host_key) ||
+      typeof value.public_key_spki_base64 !== "string" || !/^[A-Za-z0-9+/]+={0,2}$/.test(value.public_key_spki_base64) ||
+      value.public_key_spki_base64.length % 4 !== 0) fail("daemon_bootstrap_identity_invalid");
+  let spki;
+  try { spki = Buffer.from(value.public_key_spki_base64, "base64"); } catch { fail("daemon_bootstrap_identity_invalid"); }
+  if (
+    spki.toString("base64") !== value.public_key_spki_base64 ||
+    spki.length !== P256_SPKI_PREFIX.length + 65 ||
+    !spki.subarray(0, P256_SPKI_PREFIX.length).equals(P256_SPKI_PREFIX) ||
+    spki[P256_SPKI_PREFIX.length] !== 0x04 ||
+    `bbh-${createHash("sha256").update(spki).digest("hex").slice(0, 24)}` !== value.host_key
+  ) fail("daemon_bootstrap_identity_invalid");
+  return { hostKey: value.host_key, spki };
+}
+
+function checkedRelease(value, spec) {
+  const target = `${spec.platform}-${spec.arch}`;
+  if (!value || typeof value !== "object" || value.target !== target ||
+      typeof value.releaseVersion !== "string" || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(value.releaseVersion) ||
+      typeof value.sourceCommit !== "string" || !/^[0-9a-f]{40}$/.test(value.sourceCommit) ||
+      typeof value.sha256 !== "string" || !/^[0-9a-f]{64}$/.test(value.sha256) ||
+      !Buffer.isBuffer(value.payload)) fail("daemon_bootstrap_release_invalid");
+  return value;
+}
+
+function pemForSpki(spki) {
+  return `-----BEGIN PUBLIC KEY-----\n${spki.toString("base64")}\n-----END PUBLIC KEY-----\n`;
+}
+
+export function bootstrapResumeRecord(spec, identity, profilePhase = "pending") {
+  const publicIdentity = checkedIdentity(identity);
+  if (!["pending", "profile_delivered"].includes(profilePhase)) fail("daemon_bootstrap_resume_invalid");
+  return {
+    schema_version: 2,
+    host_key: publicIdentity.hostKey,
+    public_key_spki_sha256: `sha256:${createHash("sha256").update(publicIdentity.spki).digest("hex")}`,
+    server_url: spec.serverUrl,
+    ssh_host: spec.sshHost,
+    service_user: spec.serviceUser,
+    daemon_binary: spec.daemonBinary,
+    profile_path: spec.profilePath,
+    requesting_host: spec.requestingHost,
+    runtime_engine_id: spec.runtimeEngineId,
+    platform: spec.platform,
+    arch: spec.arch,
+    release_root: spec.releaseRoot,
+    home: spec.home,
+    config: spec.config,
+    approval_timeout_seconds: spec.approvalTimeoutSeconds,
+    profile_phase: profilePhase,
+  };
+}
+
+function sameResumeRecord(left, right) {
+  return left && right && typeof left === "object" && typeof right === "object" &&
+    Object.keys(left).length === Object.keys(right).length && Object.keys(left).every((key) => left[key] === right[key]);
+}
+
+function completedProfilePhase(stored, pending, delivered) {
+  if (sameResumeRecord(stored, pending)) return false;
+  if (sameResumeRecord(stored, delivered)) return true;
+  fail("daemon_bootstrap_resume_mismatch");
+}
+
+function profileDeliveryCompleted(enrollment, hostKey) {
+  return enrollment && typeof enrollment === "object" && !Array.isArray(enrollment) &&
+    enrollment.outcome === "profile_delivered" && enrollment.expected_host_key === hostKey &&
+    enrollment.delivery && typeof enrollment.delivery === "object" && enrollment.delivery.installed === true;
+}
+
+export function dockerApprovalUrl(hostKey) {
+  if (typeof hostKey !== "string" || !HOST_KEY_RE.test(hostKey)) fail("daemon_bootstrap_identity_invalid");
+  // Docker.tsx treats this query shape as a Helper approval return and opens
+  // PairHostWizard for the exact candidate. This is not an invented route.
+  return `${DOCKER_APPROVAL_ORIGIN}/docker?host_key=${hostKey}`;
+}
+
+/** Build the complete server-validated registration body from target public data. */
+export function bootstrapRegistrationPayload({ identity, release, runtimeEngineId } = {}) {
+  const target = { platform: release?.target?.split("-")[0], arch: release?.target?.split("-").slice(1).join("-") };
+  // checkedRelease needs only the target tuple; its caller has already selected
+  // platform/arch and the remaining shape is intentionally validated below.
+  if (!target.platform || !target.arch) fail("daemon_bootstrap_release_invalid");
+  const checked = checkedRelease(release, target);
+  const publicIdentity = checkedIdentity(identity);
+  if (typeof runtimeEngineId !== "string" || !ENGINE_ID_RE.test(runtimeEngineId)) fail("daemon_bootstrap_runtime_identity_invalid");
+  return {
+    host_key: publicIdentity.hostKey,
+    p256_public_key_pem: pemForSpki(publicIdentity.spki),
+    device_consent: true,
+    helper_version: `go-daemon/${checked.releaseVersion}`,
+    helper_git_sha: checked.sourceCommit,
+    helper_protocol_version: 2,
+    runtime_kind: "go_daemon",
+    runtime_artifact_sha256: `sha256:${checked.sha256}`,
+    runtime_engine_id: runtimeEngineId,
+  };
+}
+
+function registrationState(value, hostKey) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || value.host_key !== hostKey) {
+    fail("daemon_bootstrap_registration_invalid");
+  }
+  if (value.registered === false && value.state === "unregistered") return { registered: false, state: "unregistered" };
+  if (value.registered === true && typeof value.state === "string" && value.state && value.device_consent === true) {
+    return { registered: true, state: value.state, deviceConsent: true };
+  }
+  fail("daemon_bootstrap_registration_invalid");
+}
+
+function pendingReceipt(hostKey) {
+  return {
+    outcome: "approval_required",
+    state: "unregistered",
+    host_key: hostKey,
+    approval_url: dockerApprovalUrl(hostKey),
+    resume_mode: "resume",
+  };
+}
+
+function approvalTerminal(state, hostKey) {
+  if (!["denied", "expired", "cancelled"].includes(state)) fail("daemon_bootstrap_approval_wait_invalid");
+  return { outcome: `approval_${state}`, state, host_key: hostKey };
+}
+
+/**
+ * Drive the explicit requester-owned lifecycle. The public CLI uses one bounded
+ * pushed approval waiter; it gets exactly one wake and re-registers the same
+ * public body before it may create a daemon device family.
+ */
+export async function bootstrapFreshDaemon(input, {
+  verifyRemoteIdentity = verifyRemoteServiceIdentity,
+  createIdentity = createRemoteBootstrapIdentity,
+  inspectIdentity = inspectRemoteBootstrapIdentity,
+  validateRelease = validateDaemonRelease,
+  stageRemote = stageRemoteDaemonRelease,
+  registerHost,
+  awaitApproval = null,
+  onApprovalRequired = null,
+  resumeStore = null,
+  enroll = enrollDaemonDeviceProfileFromBootstrapIdentity,
+  deliver = deliverDaemonProfileFromBootstrapIdentityOverSSH,
+  installRemote = installRemoteService,
+} = {}) {
+  const spec = checkedSpec(input);
+  if (typeof registerHost !== "function" || typeof verifyRemoteIdentity !== "function" ||
+      typeof createIdentity !== "function" || typeof inspectIdentity !== "function" ||
+      typeof validateRelease !== "function" || typeof stageRemote !== "function" || typeof enroll !== "function" ||
+      typeof deliver !== "function" || typeof installRemote !== "function" ||
+      (awaitApproval !== null && typeof awaitApproval !== "function") ||
+      (onApprovalRequired !== null && typeof onApprovalRequired !== "function") ||
+      (resumeStore !== null && (typeof resumeStore !== "object" || typeof resumeStore.save !== "function" ||
+        typeof resumeStore.load !== "function" || typeof resumeStore.remove !== "function"))) fail("daemon_bootstrap_dependencies_invalid");
+
+  let release;
+  try { release = checkedRelease(await validateRelease({ releaseRoot: spec.releaseRoot }, { platform: spec.platform, arch: spec.arch }), spec); }
+  catch (error) {
+    if (error instanceof DaemonBootstrapError) throw error;
+    fail("daemon_bootstrap_release_invalid");
+  }
+  const trustedDaemonBinary = installedBinaryPath(release);
+  try {
+    const staged = await stageRemote({
+      platform: spec.platform,
+      host: spec.sshHost,
+      user: spec.serviceUser,
+      release,
+    });
+    if (!staged || staged.outcome !== "staged" || staged.binary !== trustedDaemonBinary ||
+        staged.service_user !== spec.serviceUser || staged.host !== spec.sshHost) fail("daemon_bootstrap_release_stage_failed");
+  } catch { fail("daemon_bootstrap_release_stage_failed"); }
+
+  let remote;
+  try { remote = await verifyRemoteIdentity({ sshHost: spec.sshHost, serviceUser: spec.serviceUser }); }
+  catch { fail("daemon_bootstrap_remote_identity_invalid"); }
+  if (!remote || typeof remote.directInstall !== "boolean") fail("daemon_bootstrap_remote_identity_invalid");
+
+  const identityInput = {
+    sshHost: spec.sshHost,
+    serviceUser: spec.serviceUser,
+    daemonBinary: trustedDaemonBinary,
+    directInstall: remote.directInstall,
+  };
+  let identity;
+  try { identity = await (spec.mode === "create" ? createIdentity(identityInput) : inspectIdentity(identityInput)); }
+  catch { fail("daemon_bootstrap_identity_unavailable"); }
+  const publicIdentity = checkedIdentity(identity);
+  const storedResume = bootstrapResumeRecord(spec, identity);
+  const deliveredResume = bootstrapResumeRecord(spec, identity, "profile_delivered");
+  let reuseCompletedProfile = false;
+  if (resumeStore) {
+    try {
+      if (spec.mode === "create") await resumeStore.save(storedResume);
+      else reuseCompletedProfile = completedProfilePhase(
+        await resumeStore.load(publicIdentity.hostKey),
+        storedResume,
+        deliveredResume,
+      );
+    } catch (error) {
+      if (error instanceof DaemonBootstrapError) throw error;
+      fail(error?.message === "daemon_bootstrap_resume_conflict" ? "daemon_bootstrap_resume_mismatch" : "daemon_bootstrap_resume_unavailable");
+    }
+  }
+
+  const registration = bootstrapRegistrationPayload({ identity, release, runtimeEngineId: spec.runtimeEngineId });
+  let state;
+  try { state = registrationState(await registerHost(registration), publicIdentity.hostKey); }
+  catch (error) {
+    if (error instanceof DaemonBootstrapError) throw error;
+    fail("daemon_bootstrap_registration_failed");
+  }
+  if (!state.registered) {
+    const pending = pendingReceipt(publicIdentity.hostKey);
+    if (!awaitApproval) return pending;
+    // This is a display-only receipt. It makes the established owner action
+    // visible before the process parks, without changing authorization flow.
+    if (onApprovalRequired) await onApprovalRequired(pending);
+    let approval;
+    try {
+      approval = await awaitApproval({
+        hostKey: publicIdentity.hostKey,
+        approvalUrl: dockerApprovalUrl(publicIdentity.hostKey),
+        timeoutSeconds: spec.approvalTimeoutSeconds,
+      });
+    } catch (error) {
+      // A failed wait transport/receipt is not a human cancellation. Fail
+      // closed; only the semantic waiter may return an explicit cancellation.
+      if (error instanceof DaemonBootstrapError) throw error;
+      fail("daemon_bootstrap_approval_wait_failed");
+    }
+    if (!approval || typeof approval !== "object" || typeof approval.state !== "string") fail("daemon_bootstrap_approval_wait_invalid");
+    if (approval.state !== "approved") return approvalTerminal(approval.state, publicIdentity.hostKey);
+    try { state = registrationState(await registerHost(registration), publicIdentity.hostKey); }
+    catch (error) {
+      if (error instanceof DaemonBootstrapError) throw error;
+      fail("daemon_bootstrap_registration_failed");
+    }
+    if (!state.registered) return pendingReceipt(publicIdentity.hostKey);
+  }
+
+  let enrollment;
+  if (reuseCompletedProfile) {
+    // The persisted phase is accepted only after inspectIdentity established the
+    // same target-owned P-256 identity and exact custody/spec record above.
+    enrollment = {
+      outcome: "profile_delivered",
+      expected_host_key: publicIdentity.hostKey,
+      delivery: { installed: true },
+      reused: true,
+    };
+  } else {
+    try {
+      enrollment = await enroll({
+        serverUrl: spec.serverUrl,
+        expectedHostKey: publicIdentity.hostKey,
+        requestingHost: spec.requestingHost,
+        ...(spec.caller ? { caller: spec.caller } : {}),
+        ...(spec.callerHarness ? { callerHarness: spec.callerHarness } : {}),
+        ...(spec.callerTicket ? { callerTicket: spec.callerTicket } : {}),
+        deliver: (artifact) => deliver({
+          artifact,
+          sshHost: spec.sshHost,
+          serviceUser: spec.serviceUser,
+          daemonBinary: trustedDaemonBinary,
+          profilePath: spec.profilePath,
+          expectedHostKey: publicIdentity.hostKey,
+          directInstall: remote.directInstall,
+        }),
+      });
+    } catch (error) {
+      if (error instanceof DaemonBootstrapError) throw error;
+      fail("daemon_bootstrap_enrollment_failed");
+    }
+    if (!profileDeliveryCompleted(enrollment, publicIdentity.hostKey)) fail("daemon_bootstrap_enrollment_failed");
+    if (resumeStore) {
+      try { await resumeStore.save(deliveredResume); }
+      catch (error) {
+        if (error instanceof DaemonBootstrapError) throw error;
+        fail(error?.message === "daemon_bootstrap_resume_conflict" ? "daemon_bootstrap_resume_mismatch" : "daemon_bootstrap_resume_unavailable");
+      }
+    }
+  }
+
+  const serviceSpec = {
+    user: spec.serviceUser,
+    home: spec.home,
+    config: spec.config,
+    binary: installedBinaryPath(release),
+  };
+  const definition = spec.platform === "darwin" ? renderMacDaemon(serviceSpec) : renderLinuxUnit(serviceSpec);
+  let installation;
+  try {
+    installation = await installRemote({
+      platform: spec.platform,
+      host: spec.sshHost,
+      user: spec.serviceUser,
+      definition,
+      release,
+      config: spec.config,
+    });
+  } catch { fail("daemon_bootstrap_installation_failed"); }
+  if (!installation || typeof installation !== "object" || installation.outcome !== "installed") {
+    fail("daemon_bootstrap_installation_failed");
+  }
+  if (resumeStore) {
+    try { await resumeStore.remove(publicIdentity.hostKey); }
+    catch { fail("daemon_bootstrap_resume_remove_failed"); }
+  }
+  return {
+    outcome: "installed",
+    host_key: publicIdentity.hostKey,
+    registration: { state: state.state, device_consent: true },
+    enrollment,
+    installation,
+  };
+}