@botbuddy/cli 1.59.6 → 1.59.8

package/src/daemon/commands.mjs

@@ -0,0 +1,478 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { lstat, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { registerContainerHost } from "../api.mjs";
+import { awaitHostApproval } from "./approval-wait.mjs";
+import { bootstrapFreshDaemon } from "./bootstrap.mjs";
+import { createBootstrapResumeStore } from "./bootstrap-resume.mjs";
+import { validateDaemonRelease, validateDaemonVersion } from "./release.mjs";
+import {
+  installedBinaryPath,
+  installRemoteService,
+  installService,
+  stageRemoteDaemonRelease,
+  serviceStatus,
+  serviceUserUid,
+  assertSshHost,
+} from "./installer.mjs";
+import { renderLinuxUnit, renderMacDaemon } from "./service.mjs";
+import { buildRuntimeConfig } from "./runtime-config.mjs";
+import {
+  DAEMON_PRODUCTION_MCP_SERVER,
+  enrollDaemonDeviceProfileFromHelperIdentity,
+  enrollDaemonDeviceProfileFromBootstrapIdentity,
+} from "./enrollment.mjs";
+import {
+  createRemoteBootstrapIdentity,
+  deliverDaemonProfileFromBootstrapIdentityOverSSH,
+  deliverDaemonProfileFromHelperIdentityOverSSH,
+  inspectRemoteBootstrapIdentity,
+  verifyRemoteHelperIdentity as verifyRemoteHelperIdentityOnTarget,
+  verifyRemoteServiceIdentity,
+} from "./profile-delivery.mjs";
+
+const execFile = promisify(execFileCallback);
+const fail = (code) => {
+  throw new Error(code);
+};
+const platformName = (value) => value === "macos" ? "darwin" : value;
+
+export const daemonHelp = `Usage:
+  bb daemon render <darwin|linux> '<json service spec>'
+  bb daemon install <darwin|linux> '<json service spec>'
+  bb daemon status <darwin|linux> ['<json ssh spec>']
+  bb daemon config-render '<json host policy>'
+  bb daemon enroll '<json host-bound enrollment spec>'
+  bb daemon bootstrap '<json fresh-host bootstrap spec>'
+
+The Go payload is verified from the extracted universal package before sudo.
+Install runs the Go runtime's --check-config receipt before loading a native,
+root-owned service. Add "sshHost" and target "arch" to deploy from this CLI
+over SSH; the target receives only the Go payload and native service commands.
+
+Enrollment keeps the existing Mini P-256 identity on the target. After a
+read-only target custody check, it writes a distinct, host-bound Daemon OAuth
+profile through the public Go stdin installer. It does not start or activate
+the service.
+
+Bootstrap creates (or, with mode "resume", inspects) a target-private identity,
+registers only its public SPKI through the authenticated MCP control-plane route,
+and prints the exact /docker approval URL when policy approval is pending. It
+then uses one bounded pushed bb wait on that exact host (never a local poll),
+re-registers the same SPKI/consent tuple, and proceeds only when the server
+again reports the host registered. Resume never regenerates the target identity.
+It then performs a distinct daemon device grant, schema-v3 profile delivery,
+and the existing remote native install/check-config/service activation path.`;
+
+const DAEMON_HOST_KEY_RE = /^bbh-[0-9a-f]{24}$/;
+const SAFE_ABSOLUTE_PATH = /^\/(?:[A-Za-z0-9._-]+\/)*[A-Za-z0-9._-]+$/;
+const SAFE_SERVICE_USER = /^[a-z_][a-z0-9_-]*$/i;
+
+function releaseCanBeStaged(release, platform) {
+  const target = platform === "darwin" ? "darwin-arm64" : "linux-x64";
+  return release &&
+    release.target === target &&
+    /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(release.releaseVersion) &&
+    /^[0-9a-f]{40}$/.test(release.sourceCommit) &&
+    /^[0-9a-f]{64}$/.test(release.sha256) &&
+    Buffer.isBuffer(release.payload) &&
+    createHash("sha256").update(release.payload).digest("hex") === release.sha256;
+}
+
+async function safeRootAncestry(path, inspect = lstat) {
+  const segments = path.split("/").filter(Boolean);
+  let current = "";
+  for (const segment of segments) {
+    current += `/${segment}`;
+    const stat = await inspect(current).catch((error) => error?.code === "ENOENT" ? null : Promise.reject(error));
+    if (!stat) return;
+    if (!stat.isDirectory() || stat.isSymbolicLink() || stat.uid !== 0 || (stat.mode & 0o022) !== 0) {
+      fail("daemon_stage_unsafe_destination");
+    }
+  }
+}
+
+function checksumCommand(platform) {
+  return platform === "darwin" ? ["shasum", ["-a", "256"]] : ["sha256sum", []];
+}
+
+function checksumMatches(output, expected) {
+  return String(output ?? "").trim().split(/\s+/)[0] === expected;
+}
+
+async function assertInstalledDaemonBinary(binary, release, platform, exec) {
+  const [checksumCommandName, checksumArgs] = checksumCommand(platform);
+  const statArgs = platform === "darwin"
+    ? ["stat", "-f", "%u:%OLp", binary]
+    : ["stat", "-c", "%u:%a", binary];
+  try {
+    await exec("sudo", ["test", "-f", binary]);
+    await exec("sudo", ["test", "!", "-L", binary]);
+    const [ownership, checksum] = await Promise.all([
+      exec("sudo", statArgs),
+      exec("sudo", [checksumCommandName, ...checksumArgs, binary]),
+    ]);
+    if (!/^0:(?:755|100755)$/.test(String(ownership?.stdout ?? "").trim()) || !checksumMatches(checksum?.stdout, release.sha256)) {
+      fail("daemon_stage_installed_payload_invalid");
+    }
+  } catch (error) {
+    if (error?.message?.startsWith("daemon_stage_")) throw error;
+    fail("daemon_stage_installed_payload_invalid");
+  }
+}
+
+// Install a snapshot of the already hash-verified payload before asking the
+// unprivileged service identity to execute it. The extracted package tree is
+// deliberately never made traversable for that identity.
+export async function stageVerifiedDaemonBinary(release, {
+  platform,
+  exec = execFile,
+  makeTemp = mkdtemp,
+  write = writeFile,
+  remove = rm,
+  inspect = lstat,
+  random = randomUUID,
+} = {}) {
+  if (!new Set(["darwin", "linux"]).has(platform) || !releaseCanBeStaged(release, platform)) {
+    fail("daemon_stage_release_invalid");
+  }
+  const binary = installedBinaryPath(release);
+  const binaryDirectory = binary.slice(0, binary.lastIndexOf("/"));
+  await safeRootAncestry(binaryDirectory, inspect);
+  const localDirectory = await makeTemp(join(tmpdir(), "botbuddy-daemon-"));
+  const snapshot = join(localDirectory, "botbuddy-daemon");
+  const binaryStage = join(binaryDirectory, `.botbuddy-daemon.${release.sha256}.${random()}`);
+  let staged = false;
+  try {
+    await write(snapshot, release.payload, { mode: 0o500 });
+    let existing = false;
+    try {
+      await exec("sudo", ["test", "-e", binary]);
+      existing = true;
+    } catch (error) {
+      if (error?.code !== 1) throw error;
+    }
+    if (!existing) {
+      const group = platform === "darwin" ? "wheel" : "root";
+      const [checksumCommandName, checksumArgs] = checksumCommand(platform);
+      await exec("sudo", ["install", "-d", "-o", "root", "-g", group, "-m", "0755", binaryDirectory]);
+      await exec("sudo", ["install", "-o", "root", "-g", group, "-m", "0755", snapshot, binaryStage]);
+      staged = true;
+      const checksum = await exec("sudo", [checksumCommandName, ...checksumArgs, binaryStage]);
+      if (!checksumMatches(checksum?.stdout, release.sha256)) fail("daemon_stage_digest_invalid");
+      await exec("sudo", ["mv", "-n", binaryStage, binary]);
+      staged = false;
+    }
+    await assertInstalledDaemonBinary(binary, release, platform, exec);
+    return { ...release, binary };
+  } finally {
+    if (staged) await exec("sudo", ["rm", "-f", binaryStage]).catch(() => {});
+    await remove(localDirectory, { recursive: true, force: true });
+  }
+}
+
+function enrollmentSpec(args) {
+  if (args.length !== 2) fail("Usage: bb daemon enroll '<json host-bound enrollment spec>'");
+  let spec;
+  try { spec = JSON.parse(args[1]); } catch { fail("daemon_enrollment_spec_invalid"); }
+  if (!spec || typeof spec !== "object" || Array.isArray(spec)) fail("daemon_enrollment_spec_invalid");
+  const allowed = new Set([
+    "serverUrl", "sshHost", "serviceUser", "daemonBinary", "profilePath", "expectedHostKey", "requestingHost",
+    "caller", "callerHarness", "callerTicket",
+  ]);
+  if (Object.keys(spec).some((key) => !allowed.has(key))) fail("daemon_enrollment_spec_invalid");
+  if (
+    spec.serverUrl !== DAEMON_PRODUCTION_MCP_SERVER ||
+    typeof spec.sshHost !== "string" ||
+    typeof spec.serviceUser !== "string" || !SAFE_SERVICE_USER.test(spec.serviceUser) ||
+    typeof spec.daemonBinary !== "string" || !SAFE_ABSOLUTE_PATH.test(spec.daemonBinary) ||
+    typeof spec.profilePath !== "string" || !SAFE_ABSOLUTE_PATH.test(spec.profilePath) || !spec.profilePath.endsWith("/profile.json") ||
+    typeof spec.expectedHostKey !== "string" || !DAEMON_HOST_KEY_RE.test(spec.expectedHostKey) ||
+    typeof spec.requestingHost !== "string" || spec.requestingHost.length === 0 || Buffer.byteLength(spec.requestingHost, "utf8") > 80
+  ) fail("daemon_enrollment_spec_invalid");
+  try { assertSshHost(spec.sshHost); } catch { fail("daemon_enrollment_spec_invalid"); }
+  return spec;
+}
+
+export function parseDaemonArgs(args) {
+  const [subcommand, requestedPlatform, ...rest] = args;
+  const platform = platformName(requestedPlatform);
+  if (
+    !new Set(["render", "install"]).has(subcommand) ||
+    !new Set(["darwin", "linux"]).has(platform) || rest.length !== 1
+  ) {
+    fail(
+      "Usage: bb daemon <render|install> <darwin|linux> '<json service spec>'",
+    );
+  }
+  let spec;
+  try {
+    spec = JSON.parse(rest[0]);
+  } catch {
+    fail("daemon service spec must be JSON");
+  }
+  if (!spec || typeof spec !== "object" || Array.isArray(spec)) {
+    fail("daemon service spec must be JSON");
+  }
+  return { subcommand, platform, spec };
+}
+
+export async function checkRuntimeConfig(
+  release,
+  config,
+  { exec = execFile, serviceUser } = {},
+) {
+  if (
+    typeof serviceUser !== "string" ||
+    !SAFE_SERVICE_USER.test(serviceUser)
+  ) fail("daemon_runtime_user_mismatch");
+  let result;
+  try {
+    result = await exec(
+      "sudo",
+      ["-u", serviceUser, release.binary, "--check-config", "--config", config],
+      { timeout: 5_000, maxBuffer: 16 * 1024 },
+    );
+  } catch {
+    fail("daemon_runtime_config_invalid");
+  }
+  let receipt;
+  try {
+    receipt = JSON.parse(String(result?.stdout ?? ""));
+  } catch {
+    fail("daemon_runtime_config_invalid");
+  }
+  if (!receipt || Object.keys(receipt).length !== 1 || receipt.valid !== true) {
+    fail("daemon_runtime_config_invalid");
+  }
+  return receipt;
+}
+
+export async function checkRuntimeVersion(release, exec = execFile) {
+  let result;
+  try {
+    result = await exec(release.binary, ["--version"], {
+      timeout: 5_000,
+      maxBuffer: 16 * 1024,
+    });
+  } catch {
+    fail("daemon_release_version_invalid");
+  }
+  const runtimeTarget = release.target === "linux-x64"
+    ? "linux-amd64"
+    : release.target;
+  return validateDaemonVersion(String(result?.stdout ?? ""), {
+    releaseVersion: release.releaseVersion,
+    sourceCommit: release.sourceCommit,
+    target: runtimeTarget,
+  });
+}
+
+export async function cmdDaemon(args, {
+  log = console.log,
+  notice = (line) => process.stderr.write(`${line}\n`),
+  install = installService,
+  stageLocal = stageVerifiedDaemonBinary,
+  status = serviceStatus,
+  validateRelease = validateDaemonRelease,
+  installRemote = installRemoteService,
+  stageRemote = stageRemoteDaemonRelease,
+  resolveUser = serviceUserUid,
+  verifyVersion = checkRuntimeVersion,
+  verifyRuntime = checkRuntimeConfig,
+  enroll = enrollDaemonDeviceProfileFromHelperIdentity,
+  deliver = deliverDaemonProfileFromHelperIdentityOverSSH,
+  verifyRemoteIdentity = verifyRemoteServiceIdentity,
+  verifyRemoteHelperIdentity = verifyRemoteHelperIdentityOnTarget,
+  bootstrap = bootstrapFreshDaemon,
+  registerHost = registerContainerHost,
+  createBootstrapIdentity = createRemoteBootstrapIdentity,
+  inspectBootstrapIdentity = inspectRemoteBootstrapIdentity,
+  enrollBootstrap = enrollDaemonDeviceProfileFromBootstrapIdentity,
+  deliverBootstrap = deliverDaemonProfileFromBootstrapIdentityOverSSH,
+  awaitApproval = awaitHostApproval,
+  resumeStore = createBootstrapResumeStore(),
+} = {}) {
+  if (["--help", "-h", "help", undefined].includes(args[0])) {
+    log(daemonHelp);
+    return 0;
+  }
+  if (args[0] === "config-render") {
+    if (args.length !== 2) {
+      fail("Usage: bb daemon config-render '<json host policy>'");
+    }
+    let input;
+    try {
+      input = JSON.parse(args[1]);
+    } catch {
+      fail("daemon runtime config must be JSON");
+    }
+    log(JSON.stringify(buildRuntimeConfig(input)));
+    return 0;
+  }
+  if (args[0] === "bootstrap") {
+    if (args.length !== 2) fail("Usage: bb daemon bootstrap '<json fresh-host bootstrap spec>'");
+    let spec;
+    try { spec = JSON.parse(args[1]); } catch { fail("daemon_bootstrap_spec_invalid"); }
+    let receipt;
+    try {
+      receipt = await bootstrap(spec, {
+        verifyRemoteIdentity,
+        createIdentity: createBootstrapIdentity,
+        inspectIdentity: inspectBootstrapIdentity,
+        validateRelease,
+        stageRemote,
+        registerHost: async (payload) => {
+          const result = await registerHost(payload, { serverUrl: spec?.serverUrl });
+          if (!result?.ok) throw new Error("daemon_bootstrap_registration_failed");
+          return result.data;
+        },
+        enroll: enrollBootstrap,
+        deliver: deliverBootstrap,
+        installRemote,
+        onApprovalRequired: ({ approval_url: approvalUrl, host_key: hostKey }) => {
+          notice(`bb daemon bootstrap: owner approval required for ${hostKey}: ${approvalUrl}`);
+        },
+        resumeStore,
+        ...(typeof awaitApproval === "function" ? { awaitApproval } : {}),
+      });
+    } catch (error) {
+      if (error?.message?.startsWith("daemon_bootstrap_")) throw error;
+      fail("daemon_bootstrap_failed");
+    }
+    log(JSON.stringify(receipt));
+    return receipt.outcome === "installed" ? 0 : 4;
+  }
+  if (args[0] === "enroll") {
+    const spec = enrollmentSpec(args);
+    let remoteIdentity;
+    try {
+      remoteIdentity = await verifyRemoteIdentity({
+        sshHost: spec.sshHost,
+        serviceUser: spec.serviceUser,
+      });
+    } catch {
+      fail("daemon_enrollment_remote_identity_invalid");
+    }
+    if (!remoteIdentity || typeof remoteIdentity.directInstall !== "boolean") {
+      fail("daemon_enrollment_remote_identity_invalid");
+    }
+    try {
+      await verifyRemoteHelperIdentity({
+        sshHost: spec.sshHost,
+        serviceUser: spec.serviceUser,
+        daemonBinary: spec.daemonBinary,
+        expectedHostKey: spec.expectedHostKey,
+        directInstall: remoteIdentity.directInstall,
+      });
+    } catch {
+      fail("daemon_enrollment_remote_helper_identity_invalid");
+    }
+    const receipt = await enroll({
+      serverUrl: spec.serverUrl,
+      expectedHostKey: spec.expectedHostKey,
+      requestingHost: spec.requestingHost,
+      ...(typeof spec.caller === "string" ? { caller: spec.caller } : {}),
+      ...(typeof spec.callerHarness === "string" ? { callerHarness: spec.callerHarness } : {}),
+      ...(typeof spec.callerTicket === "string" ? { callerTicket: spec.callerTicket } : {}),
+      log,
+      deliver: (artifact) => deliver({
+        artifact,
+        sshHost: spec.sshHost,
+        serviceUser: spec.serviceUser,
+        daemonBinary: spec.daemonBinary,
+        profilePath: spec.profilePath,
+        expectedHostKey: spec.expectedHostKey,
+        directInstall: remoteIdentity.directInstall,
+      }),
+    });
+    log(JSON.stringify(receipt));
+    return 0;
+  }
+  if (args[0] === "status") {
+    const platform = platformName(args[1]);
+    if (
+      !new Set(["darwin", "linux"]).has(platform) ||
+      ![2, 3].includes(args.length)
+    ) fail("Usage: bb daemon status <darwin|linux> ['<json ssh spec>']");
+    let statusSpec = {};
+    if (args.length === 3) {
+      try {
+        statusSpec = JSON.parse(args[2]);
+      } catch {
+        fail("daemon service spec must be JSON");
+      }
+      if (
+        !statusSpec || typeof statusSpec !== "object" ||
+        Array.isArray(statusSpec) || typeof statusSpec.sshHost !== "string"
+      ) fail("daemon service spec must include sshHost");
+    }
+    log(JSON.stringify(await status({ platform, host: statusSpec.sshHost })));
+    return 0;
+  }
+  const { subcommand, platform, spec } = parseDaemonArgs(args);
+  const remote = typeof spec.sshHost === "string";
+  if (remote && typeof spec.arch !== "string") {
+    fail("daemon_remote_arch_required");
+  }
+  const release = await validateRelease({ releaseRoot: spec.releaseRoot }, {
+    platform,
+    arch: spec.arch,
+  });
+  const serviceSpec = {
+    user: spec.user,
+    home: spec.home,
+    config: spec.config,
+    binary: installedBinaryPath(release),
+  };
+  const definition = platform === "darwin"
+    ? renderMacDaemon(serviceSpec)
+    : renderLinuxUnit(serviceSpec);
+  if (subcommand === "render") {
+    log(definition);
+    return 0;
+  }
+  if (remote) {
+    const receipt = await installRemote({
+      platform,
+      host: spec.sshHost,
+      user: spec.user,
+      definition,
+      release,
+      config: spec.config,
+    });
+    log(
+      JSON.stringify({
+        schema_version: 1,
+        ...receipt,
+        release_version: release.releaseVersion,
+        source_commit: release.sourceCommit,
+      }),
+    );
+    return 0;
+  }
+  await resolveUser(spec.user);
+  if (!releaseCanBeStaged(release, platform)) fail("daemon_stage_release_invalid");
+  const stagedRelease = await stageLocal(release, { platform });
+  await verifyVersion(stagedRelease);
+  await verifyRuntime(stagedRelease, spec.config, { serviceUser: spec.user });
+  const receipt = await install({
+    platform,
+    user: spec.user,
+    definition,
+    release: stagedRelease,
+    config: spec.config,
+  });
+  log(
+    JSON.stringify({
+      schema_version: 1,
+      ...receipt,
+      release_version: release.releaseVersion,
+      source_commit: release.sourceCommit,
+    }),
+  );
+  return 0;
+}