@botbuddy/cli 1.59.6 → 1.59.8

package/src/daemon/enrollment.mjs

@@ -0,0 +1,483 @@
+// BOT-2057: an intentionally un-wired enrollment primitive for the first Mini
+// handover. It creates a NEW device-grant OAuth client/family and turns that
+// response plus an already-approved existing P-256 key into the exact private
+// profile consumed by the Go daemon. It never discovers, copies, writes, logs,
+// or rotates a Mini key itself. The caller must supply an exclusive-custody
+// delivery seam; Go has no public stdin profile writer yet.
+import { createECDH, createHash } from "node:crypto";
+
+import {
+  DEVICE_CODE_GRANT_TYPE,
+  REQUESTING_HOST_MAX,
+  pollDeviceToken,
+  requestDeviceAuthorization,
+} from "../oauth-device.mjs";
+
+export const DAEMON_CLIENT_NAME = "BotBuddy Daemon";
+export const DAEMON_DEVICE_SCOPE = "read write";
+export const DAEMON_PROFILE_VERSION = 1;
+export const DAEMON_PRODUCTION_RELAY_ORIGIN = "https://xymjddoobrfnsmawmtbc.supabase.co/functions/v1";
+export const DAEMON_PRODUCTION_MCP_SERVER = `${DAEMON_PRODUCTION_RELAY_ORIGIN}/mcp-server`;
+
+const REFRESH_GRANT_TYPE = "refresh_token";
+const SWIFT_REFERENCE_UNIX_SECONDS = 978_307_200;
+const MAX_ACCESS_TOKEN_BYTES = 16 * 1024;
+const MAX_REFRESH_TOKEN_BYTES = 1024;
+const MAX_CLIENT_ID_BYTES = 512;
+const MAX_EXPIRY_SECONDS = 31 * 24 * 60 * 60;
+const MAX_PROFILE_INSTALL_BYTES = 128 * 1024;
+const P256_SPKI_PREFIX = Buffer.from("3059301306072a8648ce3d020106082a8648ce3d030107034200", "hex");
+const PROFILE_INSTALL_FILE_ORDER = Object.freeze(["profile.json", "host.key", "credentials.json"]);
+const HELPER_IDENTITY_PROFILE_INSTALL_FILE_ORDER = Object.freeze(["profile.json", "credentials.json"]);
+const HELPER_IDENTITY_PROFILE_INSTALL_SCHEMA_VERSION = 2;
+const BOOTSTRAP_IDENTITY_PROFILE_INSTALL_FILE_ORDER = Object.freeze(["profile.json", "credentials.json"]);
+const BOOTSTRAP_IDENTITY_PROFILE_INSTALL_SCHEMA_VERSION = 3;
+
+export class DaemonEnrollmentError extends Error {
+  constructor(code) {
+    super(code);
+    this.name = "DaemonEnrollmentError";
+    this.code = code;
+  }
+}
+
+const fail = (code) => { throw new DaemonEnrollmentError(code); };
+
+function boundedString(value, maximum) {
+  return typeof value === "string" && value.length > 0 && Buffer.byteLength(value, "utf8") <= maximum
+    ? value
+    : null;
+}
+
+function normalizedHttpsUrl(value, code, { mcpServer = false, relayOrigin = false } = {}) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 2048) fail(code);
+  let parsed;
+  try { parsed = new URL(value); } catch { fail(code); }
+  if (
+    parsed.protocol !== "https:" || parsed.username || parsed.password ||
+    parsed.search || parsed.hash || !parsed.hostname ||
+    (mcpServer && parsed.pathname !== "/functions/v1/mcp-server") ||
+    (relayOrigin && parsed.pathname !== "/functions/v1")
+  ) fail(code);
+  return parsed.toString().replace(/\/$/, "");
+}
+
+function rawPrivateKey(value) {
+  if (!Buffer.isBuffer(value) && !(value instanceof Uint8Array)) fail("daemon_profile_private_key_invalid");
+  const raw = Buffer.from(value);
+  if (raw.length !== 32) fail("daemon_profile_private_key_invalid");
+  return raw;
+}
+
+/** Derive the exact bbh- host identifier that daemon/privateKeyFromRaw uses. */
+export function deriveDaemonHostKey(privateKey) {
+  const raw = rawPrivateKey(privateKey);
+  let publicKey;
+  try {
+    const curve = createECDH("prime256v1");
+    curve.setPrivateKey(raw);
+    publicKey = curve.getPublicKey(undefined, "uncompressed");
+  } catch {
+    fail("daemon_profile_private_key_invalid");
+  }
+  if (!Buffer.isBuffer(publicKey) || publicKey.length !== 65 || publicKey[0] !== 0x04) {
+    fail("daemon_profile_private_key_invalid");
+  }
+  const der = Buffer.concat([P256_SPKI_PREFIX, publicKey]);
+  return `bbh-${createHash("sha256").update(der).digest("hex").slice(0, 24)}`;
+}
+
+function verifiedExistingIdentity(privateKey, expectedHostKey) {
+  if (typeof expectedHostKey !== "string" || !/^bbh-[0-9a-f]{24}$/.test(expectedHostKey)) {
+    fail("daemon_profile_identity_invalid");
+  }
+  const raw = rawPrivateKey(privateKey);
+  if (deriveDaemonHostKey(raw) !== expectedHostKey) fail("daemon_profile_identity_mismatch");
+  return raw;
+}
+
+function profileToken(token) {
+  const accessToken = boundedString(token?.access_token, MAX_ACCESS_TOKEN_BYTES);
+  const refreshToken = boundedString(token?.refresh_token, MAX_REFRESH_TOKEN_BYTES);
+  const tokenType = token?.token_type;
+  const scope = token?.scope;
+  const tenantMode = token?.tenant_mode;
+  const expiresIn = token?.expires_in;
+  const scopes = typeof scope === "string" ? new Set(scope.trim().split(/\s+/).filter(Boolean)) : new Set();
+  if (
+    !accessToken || !refreshToken || tokenType !== "bearer" || tenantMode !== "user" ||
+    !scopes.has("write") || !Number.isSafeInteger(expiresIn) ||
+    expiresIn < 60 || expiresIn > MAX_EXPIRY_SECONDS
+  ) fail("daemon_profile_token_incomplete");
+  return { accessToken, refreshToken, expiresIn };
+}
+
+function profileClientId(value) {
+  const clientId = boundedString(value, MAX_CLIENT_ID_BYTES);
+  if (!clientId) fail("daemon_device_registration_failed");
+  return clientId;
+}
+
+function nowMilliseconds(now) {
+  const value = now();
+  if (!Number.isSafeInteger(value) || value <= 0) fail("daemon_profile_clock_invalid");
+  return value;
+}
+
+/**
+ * Build only an in-memory artifact. The delivery callback in
+ * enrollDaemonDeviceProfile is deliberately the first place these buffers may
+ * go; this module does not write a local profile or construct an SSH command.
+ */
+export function buildDaemonProfileArtifact({
+  relayOrigin = DAEMON_PRODUCTION_RELAY_ORIGIN,
+  existingHostPrivateKey,
+  expectedHostKey,
+  clientId,
+  token,
+  now = () => Date.now(),
+} = {}) {
+  const origin = normalizedHttpsUrl(relayOrigin, "daemon_profile_relay_origin_invalid", { relayOrigin: true });
+  const rawKey = verifiedExistingIdentity(existingHostPrivateKey, expectedHostKey);
+  const oauthClientId = profileClientId(clientId);
+  const profile = profileToken(token);
+  const expiresAt = Math.floor(nowMilliseconds(now) / 1000) - SWIFT_REFERENCE_UNIX_SECONDS + profile.expiresIn;
+  if (!Number.isSafeInteger(expiresAt) || expiresAt <= 0) fail("daemon_profile_clock_invalid");
+
+  const profileJSON = Buffer.from(JSON.stringify({
+    version: DAEMON_PROFILE_VERSION,
+    key_file: "host.key",
+    credential_file: "credentials.json",
+    expected_host_key: expectedHostKey,
+  }));
+  const credentialsJSON = Buffer.from(JSON.stringify({
+    accessToken: profile.accessToken,
+    expiresAt,
+    baseURL: origin,
+    clientID: oauthClientId,
+    refreshToken: profile.refreshToken,
+  }));
+  return {
+    rootMode: 0o700,
+    directories: [],
+    files: [
+      { path: "profile.json", mode: 0o600, body: profileJSON },
+      { path: "host.key", mode: 0o600, body: Buffer.from(rawKey) },
+      { path: "credentials.json", mode: 0o600, body: credentialsJSON },
+    ],
+  };
+}
+
+// Schema v2 is for an already-enrolled Mini only. It deliberately omits
+// host.key: the target daemon reads the fixed, existing Helper identity via its
+// own descriptor-pinned custody path and verifies this same public host key.
+export function buildDaemonProfileArtifactFromHelperIdentity({
+  relayOrigin = DAEMON_PRODUCTION_RELAY_ORIGIN,
+  expectedHostKey,
+  clientId,
+  token,
+  now = () => Date.now(),
+} = {}) {
+  if (typeof expectedHostKey !== "string" || !/^bbh-[0-9a-f]{24}$/.test(expectedHostKey)) {
+    fail("daemon_profile_identity_invalid");
+  }
+  const origin = normalizedHttpsUrl(relayOrigin, "daemon_profile_relay_origin_invalid", { relayOrigin: true });
+  const oauthClientId = profileClientId(clientId);
+  const profile = profileToken(token);
+  const expiresAt = Math.floor(nowMilliseconds(now) / 1000) - SWIFT_REFERENCE_UNIX_SECONDS + profile.expiresIn;
+  if (!Number.isSafeInteger(expiresAt) || expiresAt <= 0) fail("daemon_profile_clock_invalid");
+  return {
+    schemaVersion: HELPER_IDENTITY_PROFILE_INSTALL_SCHEMA_VERSION,
+    files: [
+      { path: "profile.json", mode: 0o600, body: Buffer.from(JSON.stringify({
+        version: DAEMON_PROFILE_VERSION,
+        key_file: "host.key",
+        credential_file: "credentials.json",
+        expected_host_key: expectedHostKey,
+      })) },
+      { path: "credentials.json", mode: 0o600, body: Buffer.from(JSON.stringify({
+        accessToken: profile.accessToken,
+        expiresAt,
+        baseURL: origin,
+        clientID: oauthClientId,
+        refreshToken: profile.refreshToken,
+      })) },
+    ],
+  };
+}
+
+// Schema v3 is for a genuinely fresh target identity. Like schema v2, it
+// deliberately omits host.key: the target daemon reads the scalar it created
+// in its fixed private bootstrap root and verifies this same public host key.
+export function buildDaemonProfileArtifactFromBootstrapIdentity({
+  relayOrigin = DAEMON_PRODUCTION_RELAY_ORIGIN,
+  expectedHostKey,
+  clientId,
+  token,
+  now = () => Date.now(),
+} = {}) {
+  if (typeof expectedHostKey !== "string" || !/^bbh-[0-9a-f]{24}$/.test(expectedHostKey)) {
+    fail("daemon_profile_identity_invalid");
+  }
+  const origin = normalizedHttpsUrl(relayOrigin, "daemon_profile_relay_origin_invalid", { relayOrigin: true });
+  const oauthClientId = profileClientId(clientId);
+  const profile = profileToken(token);
+  const expiresAt = Math.floor(nowMilliseconds(now) / 1000) - SWIFT_REFERENCE_UNIX_SECONDS + profile.expiresIn;
+  if (!Number.isSafeInteger(expiresAt) || expiresAt <= 0) fail("daemon_profile_clock_invalid");
+  return {
+    schemaVersion: BOOTSTRAP_IDENTITY_PROFILE_INSTALL_SCHEMA_VERSION,
+    files: [
+      { path: "profile.json", mode: 0o600, body: Buffer.from(JSON.stringify({
+        version: DAEMON_PROFILE_VERSION,
+        key_file: "host.key",
+        credential_file: "credentials.json",
+        expected_host_key: expectedHostKey,
+      })) },
+      { path: "credentials.json", mode: 0o600, body: Buffer.from(JSON.stringify({
+        accessToken: profile.accessToken,
+        expiresAt,
+        baseURL: origin,
+        clientID: oauthClientId,
+        refreshToken: profile.refreshToken,
+      })) },
+    ],
+  };
+}
+
+// The Go installer receives this on stdin. Paths, modes and ownership remain
+// Go-owned; the requester may supply only the exact three verified file bodies.
+export function encodeDaemonProfileInstallArtifact(artifact) {
+  if (
+    !artifact || artifact.rootMode !== 0o700 || !Array.isArray(artifact.directories) || artifact.directories.length !== 0 ||
+    !Array.isArray(artifact.files) || artifact.files.length !== PROFILE_INSTALL_FILE_ORDER.length
+  ) fail("daemon_profile_artifact_invalid");
+  const files = artifact.files.map((file, index) => {
+    if (!file || file.path !== PROFILE_INSTALL_FILE_ORDER[index] || file.mode !== 0o600 || !Buffer.isBuffer(file.body)) {
+      fail("daemon_profile_artifact_invalid");
+    }
+    return { name: file.path, content_base64: file.body.toString("base64") };
+  });
+  const encoded = Buffer.from(JSON.stringify({ schema_version: 1, files }));
+  if (encoded.length > MAX_PROFILE_INSTALL_BYTES) fail("daemon_profile_artifact_invalid");
+  return encoded;
+}
+
+export function encodeDaemonProfileInstallFromHelperIdentityArtifact(artifact) {
+  if (
+    !artifact || artifact.schemaVersion !== HELPER_IDENTITY_PROFILE_INSTALL_SCHEMA_VERSION ||
+    !Array.isArray(artifact.files) || artifact.files.length !== HELPER_IDENTITY_PROFILE_INSTALL_FILE_ORDER.length
+  ) fail("daemon_profile_artifact_invalid");
+  const files = artifact.files.map((file, index) => {
+    if (!file || file.path !== HELPER_IDENTITY_PROFILE_INSTALL_FILE_ORDER[index] || file.mode !== 0o600 || !Buffer.isBuffer(file.body)) {
+      fail("daemon_profile_artifact_invalid");
+    }
+    return { name: file.path, content_base64: file.body.toString("base64") };
+  });
+  const encoded = Buffer.from(JSON.stringify({ schema_version: HELPER_IDENTITY_PROFILE_INSTALL_SCHEMA_VERSION, files }));
+  if (encoded.length > MAX_PROFILE_INSTALL_BYTES) fail("daemon_profile_artifact_invalid");
+  return encoded;
+}
+
+export function encodeDaemonProfileInstallFromBootstrapIdentityArtifact(artifact) {
+  if (
+    !artifact || artifact.schemaVersion !== BOOTSTRAP_IDENTITY_PROFILE_INSTALL_SCHEMA_VERSION ||
+    !Array.isArray(artifact.files) || artifact.files.length !== BOOTSTRAP_IDENTITY_PROFILE_INSTALL_FILE_ORDER.length
+  ) fail("daemon_profile_artifact_invalid");
+  const files = artifact.files.map((file, index) => {
+    if (!file || file.path !== BOOTSTRAP_IDENTITY_PROFILE_INSTALL_FILE_ORDER[index] || file.mode !== 0o600 || !Buffer.isBuffer(file.body)) {
+      fail("daemon_profile_artifact_invalid");
+    }
+    return { name: file.path, content_base64: file.body.toString("base64") };
+  });
+  const encoded = Buffer.from(JSON.stringify({ schema_version: BOOTSTRAP_IDENTITY_PROFILE_INSTALL_SCHEMA_VERSION, files }));
+  if (encoded.length > MAX_PROFILE_INSTALL_BYTES) fail("daemon_profile_artifact_invalid");
+  return encoded;
+}
+
+async function registerDaemonDeviceClient(serverUrl, fetchImpl) {
+  let response;
+  try {
+    response = await fetchImpl(`${serverUrl}/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        client_name: DAEMON_CLIENT_NAME,
+        grant_types: [DEVICE_CODE_GRANT_TYPE, REFRESH_GRANT_TYPE],
+        token_endpoint_auth_method: "none",
+        scope: DAEMON_DEVICE_SCOPE,
+      }),
+    });
+  } catch {
+    fail("daemon_device_registration_failed");
+  }
+  let body;
+  try { body = await response.json(); } catch { fail("daemon_device_registration_failed"); }
+  if (response.status !== 201) fail("daemon_device_registration_failed");
+  return profileClientId(body?.client_id);
+}
+
+function devicePrompt(grant, log) {
+  const deviceCode = boundedString(grant?.device_code, 512);
+  const userCode = typeof grant?.user_code === "string" && /^[A-Z0-9-]{4,32}$/.test(grant.user_code) ? grant.user_code : null;
+  const uri = typeof grant?.verification_uri_complete === "string"
+    ? grant.verification_uri_complete
+    : grant?.verification_uri;
+  let verification;
+  try {
+    const parsed = new URL(uri);
+    if (parsed.protocol !== "https:" || parsed.username || parsed.password || /[\r\n]/.test(uri)) throw new Error("unsafe URI");
+    verification = parsed.toString();
+  } catch {
+    fail("daemon_device_authorization_failed");
+  }
+  if (
+    !deviceCode || !userCode || !Number.isSafeInteger(grant?.interval) || grant.interval < 1 || grant.interval > 60 ||
+    !Number.isSafeInteger(grant?.expires_in) || grant.expires_in < 60 || grant.expires_in > 3600
+  ) {
+    fail("daemon_device_authorization_failed");
+  }
+  const minutes = Math.max(1, Math.round(grant.expires_in / 60));
+  log("→ Sign in on any device:");
+  log(`  ${verification}`);
+  log(`  Code: ${userCode}   (expires in ${minutes} minute${minutes === 1 ? "" : "s"})`);
+  log("  Waiting for approval…");
+  return { deviceCode, intervalSec: grant.interval, expiresInSec: grant.expires_in };
+}
+
+function deliveredReceipt(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || value.installed !== true) {
+    fail("daemon_profile_delivery_failed");
+  }
+  // A delivery implementation may know remote paths or transport diagnostics;
+  // neither belongs in a requester receipt that could outlive its secret input.
+  return { installed: true };
+}
+
+/**
+ * Register a distinct public Daemon client, perform RFC 8628 device approval,
+ * and hand an in-memory private artifact to a caller-provided delivery seam.
+ * No caller may supply an old Helper client/refresh family, and no network or
+ * remote process is started unless this function itself is explicitly invoked.
+ */
+async function enrollDaemonDeviceProfileWithArtifact({
+  serverUrl,
+  relayOrigin = DAEMON_PRODUCTION_RELAY_ORIGIN,
+  expectedHostKey,
+  requestingHost,
+  caller = null,
+  callerHarness = null,
+  callerTicket = null,
+  fetch: fetchImpl = fetch,
+  sleep,
+  now = () => Date.now(),
+  signal = null,
+  log = (line) => console.log(line),
+  deliver,
+  buildArtifact,
+} = {}) {
+  const endpoint = normalizedHttpsUrl(serverUrl, "daemon_device_endpoint_invalid", { mcpServer: true });
+  const origin = normalizedHttpsUrl(relayOrigin, "daemon_profile_relay_origin_invalid", { relayOrigin: true });
+  if (typeof fetchImpl !== "function" || typeof log !== "function" || typeof deliver !== "function") {
+    fail("daemon_profile_delivery_required");
+  }
+  if (typeof expectedHostKey !== "string" || !/^bbh-[0-9a-f]{24}$/.test(expectedHostKey) || typeof buildArtifact !== "function") {
+    fail("daemon_profile_identity_invalid");
+  }
+  const host = boundedString(requestingHost, REQUESTING_HOST_MAX);
+  if (!host) fail("daemon_device_requesting_host_invalid");
+
+  const clientId = await registerDaemonDeviceClient(endpoint, fetchImpl);
+  let grant;
+  try {
+    grant = await requestDeviceAuthorization({
+      serverUrl: endpoint,
+      clientId,
+      scope: DAEMON_DEVICE_SCOPE,
+      caller,
+      callerHarness,
+      callerTicket,
+      requestingHost: host,
+      daemonHostKey: expectedHostKey,
+      fetch: fetchImpl,
+    });
+  } catch {
+    fail("daemon_device_authorization_failed");
+  }
+  const device = devicePrompt(grant, log);
+
+  let token;
+  try {
+    token = await pollDeviceToken({
+      serverUrl: endpoint,
+      clientId,
+      deviceCode: device.deviceCode,
+      intervalSec: device.intervalSec,
+      expiresInSec: device.expiresInSec,
+      fetch: fetchImpl,
+      ...(typeof sleep === "function" ? { sleep } : {}),
+      now,
+      signal,
+    });
+  } catch {
+    fail("daemon_device_token_failed");
+  }
+  const artifact = buildArtifact({
+    relayOrigin: origin,
+    expectedHostKey,
+    clientId,
+    token,
+    now,
+  });
+  let delivery;
+  try { delivery = deliveredReceipt(await deliver(artifact)); } catch (error) {
+    if (error instanceof DaemonEnrollmentError) throw error;
+    fail("daemon_profile_delivery_failed");
+  }
+  return {
+    outcome: "profile_delivered",
+    expected_host_key: expectedHostKey,
+    oauth_client_id: clientId,
+    delivery,
+  };
+}
+
+export async function enrollDaemonDeviceProfile({
+  existingHostPrivateKey,
+  expectedHostKey,
+  ...options
+} = {}) {
+  const rawKey = verifiedExistingIdentity(existingHostPrivateKey, expectedHostKey);
+  return enrollDaemonDeviceProfileWithArtifact({
+    ...options,
+    expectedHostKey,
+    buildArtifact: (input) => buildDaemonProfileArtifact({ ...input, existingHostPrivateKey: rawKey }),
+  });
+}
+
+// Existing-Mini public enrollment: the requester sees only the public host
+// identity. The target confirms and reads the original Helper key itself.
+export async function enrollDaemonDeviceProfileFromHelperIdentity({
+  expectedHostKey,
+  ...options
+} = {}) {
+  return enrollDaemonDeviceProfileWithArtifact({
+    ...options,
+    expectedHostKey,
+    buildArtifact: buildDaemonProfileArtifactFromHelperIdentity,
+  });
+}
+
+// Fresh-host public enrollment has the identical OAuth/device-family boundary
+// to the preserved-Helper path, but the target daemon alone owns the bootstrap
+// scalar. The requester can therefore supply only the public host key and the
+// two-file schema-v3 delivery seam.
+export async function enrollDaemonDeviceProfileFromBootstrapIdentity({
+  expectedHostKey,
+  ...options
+} = {}) {
+  return enrollDaemonDeviceProfileWithArtifact({
+    ...options,
+    expectedHostKey,
+    buildArtifact: buildDaemonProfileArtifactFromBootstrapIdentity,
+  });
+}

package/src/daemon/entrypoint.mjs

@@ -0,0 +1,14 @@
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+// Node's symlink flags can preserve either filesystem spelling. Canonicalize
+// both operands so aliases and escaped URLs cannot silently skip CLI checks.
+// Imports (including stdin/eval contexts without a main file) stay inert.
+export function isMainModule(moduleUrl, entry = process.argv[1]) {
+  if (typeof entry !== "string" || !entry) return false;
+  try {
+    return realpathSync(entry) === realpathSync(fileURLToPath(moduleUrl));
+  } catch {
+    return false;
+  }
+}