machine-bridge-mcp 2.0.0 → 3.0.0-beta.102

package/scripts/install-published-prerelease.mjs

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { defaultStateRoot, expandHome } from "../src/local/state.mjs";
+import { ACTIVATION_SCHEMA_VERSION, writePrereleaseActivation } from "./prerelease-activation.mjs";
+import { computePromotionContentDigest } from "./promotion-digest.mjs";
+import { readGithubPrerelease, readPublishedNpmPrerelease } from "./published-release.mjs";
+import { verifyCurrentReleaseAcceptance } from "./release-acceptance.mjs";
+import { assertSoakEligiblePrerelease } from "./release-channel.mjs";
+import { persistentActivationSpawnOptions, validateActivationRecoveryPayload } from "./persistent-activation-process.mjs";
+import { createHardenedNpmSession, settleHardenedNpmSession } from "./hardened-npm-session.mjs";
+import { nestedNpmEnvironment } from "../src/local/npm-environment.mjs";
+import { inspectGlobalPackageInstallation } from "./global-package-installation.mjs";
+import { resolveNpmGlobalPrefix } from "./npm-global-prefix.mjs";
+import { releaseCommandFailure, releaseDiagnostic, releaseDiagnosticEvent } from "./release-diagnostic.mjs";
+import { withReleaseRuntimeLock } from "../src/local/release-runtime-lock.mjs";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const lifecycleNpmCli = process.env.npm_execpath;
+let npmCli = "";
+let npmSession = null;
+let previousInstallation = null;
+let globalInstallAttempted = false;
+let globalInstallCompleted = false;
+let installedPrerelease = "";
+if (!lifecycleNpmCli) fail("published prerelease installation must run through npm");
+
+try {
+  if (!process.argv.includes("--allow-worker-deploy")) {
+    throw new Error("published prerelease activation updates the global package, same-name Worker, and login daemon; rerun with --allow-worker-deploy");
+  }
+  const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+  const requested = argumentValue("--version") || pkg.version;
+  const prerelease = assertSoakEligiblePrerelease(requested);
+  if (pkg.version !== prerelease.raw) {
+    throw new Error(`source checkout version ${pkg.version} does not match requested prerelease ${prerelease.raw}`);
+  }
+  const globalPrefix = resolveNpmGlobalPrefix(lifecycleNpmCli, { cwd: root, env: process.env });
+  const acceptance = verifyCurrentReleaseAcceptance(root, { npmCli: lifecycleNpmCli, env: process.env });
+  if (!acceptance.required || acceptance.metadata.package_version !== prerelease.raw) {
+    throw new Error("published prerelease installation requires the locally accepted exact prerelease source");
+  }
+  const promotionDigest = computePromotionContentDigest(root, { npmCli: lifecycleNpmCli });
+  if (acceptance.record.promotion_content_sha256 !== promotionDigest) {
+    throw new Error("current source promotion digest does not match local candidate acceptance");
+  }
+  readGithubPrerelease(prerelease.raw, { expectedArtifactSha256: acceptance.artifactSha256 });
+  npmSession = await createHardenedNpmSession();
+  npmCli = npmSession.cli;
+  const published = readPublishedNpmPrerelease(pkg.name, prerelease.raw, prerelease.npmTag, { npmCli, env: process.env });
+  if (published.integrity !== acceptance.metadata.integrity || published.shasum !== acceptance.metadata.shasum) {
+    throw new Error("npm prerelease bytes do not match the locally accepted candidate");
+  }
+
+  const stateRoot = resolve(expandHome(argumentValue("--state-dir") || defaultStateRoot()));
+  await withReleaseRuntimeLock(stateRoot, async () => {
+    previousInstallation = currentGlobalInstallation(pkg.name, globalPrefix);
+    globalInstallAttempted = true;
+    runNpm([
+      "install", "--dry-run=false", "--workspaces=false", "--ignore-scripts=false",
+      "--global", "--prefix", globalPrefix,
+      "--omit=optional", "--include=prod", "--package-lock-only=false",
+      "--allow-scripts=esbuild,workerd,sharp,fsevents",
+      `${pkg.name}@${prerelease.raw}`,
+    ]);
+    globalInstallCompleted = true;
+    const installed = currentGlobalInstallation(pkg.name, globalPrefix);
+    if (!installed || installed.version !== prerelease.raw) {
+      throw new Error(`global prerelease installation did not converge on ${prerelease.raw}`);
+    }
+    installedPrerelease = prerelease.raw;
+    disposeNpmSession();
+
+    const forwarded = forwardedActivationArgs();
+    const activation = runActivation(installed.entry, ["activate", ...forwarded, "--state-dir", stateRoot, "--json"]);
+    if (activation.version !== prerelease.raw || activation.daemon?.version !== prerelease.raw || activation.worker?.health?.version !== prerelease.raw) {
+      throw new Error("published prerelease activation did not converge on the exact registry version");
+    }
+    const recovery = validateActivationRecoveryPayload(activation);
+    const recordPath = writePrereleaseActivation({
+      schema_version: ACTIVATION_SCHEMA_VERSION,
+      package_name: pkg.name,
+      package_version: prerelease.raw,
+      source: "npm-prerelease",
+      shasum: published.shasum,
+      integrity: published.integrity,
+      promotion_content_sha256: promotionDigest,
+      activated_at: new Date().toISOString(),
+      published_at: published.publishedAt,
+      npm_dist_tag: prerelease.npmTag,
+      workspace_hash: workspaceHash(activation.workspace),
+      runtime_entry: installed.entry,
+      ...(recovery.recovered ? {
+        activation_recovered: true,
+        activation_recovery_reason: recovery.reason,
+        activation_recovery_detail: recovery.detail,
+      } : {}),
+      ...(previousInstallation ? { global_package_rollback_baseline: previousInstallation } : {}),
+    }, stateRoot);
+
+    if (recovery.recovered) {
+      console.warn(`Published prerelease activation used verified candidate-service recovery (${recovery.reason}): ${recovery.detail}`);
+    }
+    console.log(`Published prerelease activated: ${prerelease.raw}`);
+    console.log(`Worker and login daemon version: ${activation.version}`);
+    console.log(`Soak activation record: ${recordPath}`);
+    console.log("Use this prerelease normally. Any blocking issue requires a new beta/rc version and restarts the soak clock.");
+  });
+} catch (error) {
+  const settled = settleNpmSession(error);
+  const message = releaseDiagnostic(settled?.message || settled, 1600);
+  if (installedPrerelease) {
+    const previousVersion = previousInstallation?.version || "unknown";
+    fail(`${message}. The global package is now ${installedPrerelease}, but Worker/service activation may not have converged. Previous global version: ${previousVersion}. Preserve state and logs; fix forward with the exact prerelease or restore package, Worker, service definition, browser extension, and state as one verified unit.`);
+  }
+  if (globalInstallAttempted) {
+    const previousVersion = previousInstallation?.version || "unknown";
+    const installState = globalInstallCompleted
+      ? "The global installation command completed, but the exact installed package identity was not verified"
+      : "The global installation command was attempted and may have changed the installed package";
+    fail(`${message}. ${installState}. Previous global version: ${previousVersion}. Inspect the configured global prefix before retrying or activating any runtime.`);
+  }
+  fail(message);
+}
+
+function disposeNpmSession() {
+  const error = settleNpmSession();
+  if (error) throw error;
+}
+
+function settleNpmSession(primaryError = null) {
+  const session = npmSession;
+  npmSession = null;
+  return settleHardenedNpmSession(session, primaryError, "published prerelease failed and hardened npm temporary cleanup was incomplete");
+}
+
+function currentGlobalInstallation(packageName, globalPrefix) {
+  const globalRoot = runNpm(["root", "--json=false", "--parseable=false", "--workspaces=false", "--global", "--prefix", globalPrefix]).stdout.trim();
+  return inspectGlobalPackageInstallation(globalRoot, packageName);
+}
+
+function runActivation(entry, args) {
+  const result = spawnSync(
+    process.execPath,
+    [entry, ...args],
+    persistentActivationSpawnOptions({ cwd: root, env: nestedNpmEnvironment(process.env) }),
+  );
+  if (result.error || result.status !== 0) throw new Error(releaseCommandFailure("machine-mcp", ["activate"], result, { maxChars: 1600 }));
+  try { return JSON.parse(result.stdout); } catch { throw new Error("prerelease runtime activation did not return valid JSON"); }
+}
+
+function runNpm(args) {
+  const result = spawnSync(process.execPath, [npmCli, ...args], {
+    cwd: root,
+    env: nestedNpmEnvironment(process.env),
+    encoding: "utf8",
+    timeout: 300_000,
+    killSignal: "SIGKILL",
+    windowsHide: true,
+  });
+  if (result.error || result.status !== 0) throw new Error(releaseCommandFailure("npm", args, result, { maxChars: 1600 }));
+  return result;
+}
+
+function forwardedActivationArgs() {
+  const out = [];
+  const skipWithValue = new Set(["--version", "--state-dir"]);
+  for (let index = 2; index < process.argv.length; index += 1) {
+    const value = process.argv[index];
+    if (value === "--allow-worker-deploy") continue;
+    if (skipWithValue.has(value)) { index += 1; continue; }
+    if (["--version=", "--state-dir="].some((prefix) => value.startsWith(prefix))) continue;
+    if (value === "--json" || value.startsWith("--json=")) continue;
+    out.push(value);
+  }
+  return out;
+}
+
+function argumentValue(name) {
+  const exact = process.argv.find((value) => value.startsWith(`${name}=`));
+  if (exact) return exact.slice(name.length + 1);
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? process.argv[index + 1] : "";
+}
+
+function workspaceHash(workspace) {
+  const value = process.platform === "win32" ? String(workspace).toLowerCase() : String(workspace);
+  return createHash("sha256").update(value).digest("hex").slice(0, 24);
+}
+
+function fail(message) {
+  console.error(JSON.stringify(releaseDiagnosticEvent("prerelease.install.failed", message, 1800)));
+  process.exit(1);
+}

package/scripts/local-release-acceptance.mjs

@@ -5,7 +5,6 @@ import {
   mkdtempSync,
   readFileSync,
   rmSync,
-  writeFileSync,
 } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { tmpdir } from "node:os";
@@ -16,74 +15,120 @@ import {
   ACCEPTANCE_SCHEMA_VERSION,
   acceptancePath,
   packProject,
-  requiresLocalAcceptance,
   verifyAcceptanceRecord,
   verifyCurrentReleaseAcceptance,
   verifyTarball,
 } from "./release-acceptance.mjs";
+import { computePromotionContentDigest } from "./promotion-digest.mjs";
+import { parseReleaseVersion } from "./release-channel.mjs";
+import { validateCandidateManifest } from "./release-candidate-manifest.mjs";
+import { replaceFileAtomicallySync } from "../src/local/exclusive-file.mjs";
+import { resolveTrustedGitExecutable } from "../src/local/trusted-git-executable.mjs";
+import { nestedNpmEnvironment } from "../src/local/npm-environment.mjs";
+import { releaseCommandFailure, releaseDiagnosticEvent } from "./release-diagnostic.mjs";
+import { createHardenedNpmSession } from "./hardened-npm-session.mjs";
+import { readReleaseOAuthCanaryEvidence } from "./release-oauth-canary-evidence.mjs";
+import { assertFreshFullVerificationReceipt } from "./verification-state.mjs";
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const candidateDirectory = join(root, ".release-candidate");
 const candidateManifestPath = join(candidateDirectory, "manifest.json");
 const mode = process.argv[2] || "--verify";
+const git = resolveTrustedGitExecutable({ workspace: root });
 
 try {
-  if (mode === "--prepare") prepareCandidate();
-  else if (mode === "--record") recordAcceptance();
-  else if (mode === "--verify") verifyAcceptance();
-  else fail("usage: node scripts/local-release-acceptance.mjs [--prepare|--record|--verify]");
+  await runWithHardenedNpm();
 } catch (error) {
   fail(error?.message || error);
 }
 
-function prepareCandidate() {
-  const pkg = readPackage();
-  if (!requiresLocalAcceptance(pkg.version)) {
-    throw new Error(`local acceptance policy begins at ${pkg.name} 1.2.8; current version is ${pkg.version}`);
+async function runWithHardenedNpm() {
+  let session = null;
+  let primaryError = null;
+  try {
+    session = await createHardenedNpmSession();
+    if (mode === "--prepare") prepareCandidate(session.cli);
+    else if (mode === "--record") recordAcceptance(session.cli);
+    else if (mode === "--verify") verifyAcceptance(session.cli);
+    else throw new Error("usage: node scripts/local-release-acceptance.mjs [--prepare|--record|--verify]");
+  } catch (error) {
+    primaryError = error;
+  }
+  let cleanupError = null;
+  try { session?.dispose(); } catch (error) { cleanupError = error; }
+  if (primaryError && cleanupError) {
+    throw new AggregateError([primaryError, cleanupError], "local release acceptance failed and hardened npm cleanup was incomplete");
   }
-  rmSync(candidateDirectory, { recursive: true, force: true });
+  if (primaryError) throw primaryError;
+  if (cleanupError) throw cleanupError;
+}
+
+function prepareCandidate(npmCli) {
+  const pkg = readPackage();
+  const fullVerification = assertFreshFullVerificationReceipt(root);
+  rmSync(candidateDirectory, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
   mkdirSync(candidateDirectory, { recursive: true });
-  const metadata = packProject(root, candidateDirectory);
+  const metadata = packProject(root, candidateDirectory, { npmCli, env: process.env });
   const manifest = {
     schema_version: ACCEPTANCE_SCHEMA_VERSION,
     result: "pending",
     ...metadata,
+    promotion_content_sha256: computePromotionContentDigest(root, { npmCli }),
     prepared_at: new Date().toISOString(),
   };
-  writeFileSync(candidateManifestPath, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
+  replaceFileAtomicallySync(candidateManifestPath, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
   const phrase = confirmationPhrase(pkg.name, pkg.version);
   console.log(`Release candidate created: ${join(candidateDirectory, metadata.filename)}`);
-  console.log("After the repository owner explicitly authorizes this exact candidate in the active conversation, the coding agent starts it through Machine Bridge with:");
-  console.log("npm run release:candidate:start -- --allow-worker-deploy");
-  console.log("The owner does not need to run a terminal authorization command. The coding agent keeps the candidate running while verifying connection readiness and representative functionality through Machine Bridge.");
-  console.log("After that observed live verification succeeds, the coding agent records acceptance with:");
+  console.log(`Reused exact-tree full verification from ${fullVerification.verified_at}.`);
+  parseReleaseVersion(pkg.version);
+  console.log("Before live activation, the coding agent must reverify current source identity, package modes, tarball integrity, and disposable installability with direct Node argv (not npm lifecycle):");
+  console.log("node scripts/start-release-candidate.mjs --install-only");
+  console.log("Only after that non-live preflight succeeds and the repository owner explicitly authorizes activation may the owner or authorized agent run this exact persistent command:");
+  console.log("npm run release:candidate:activate -- --allow-worker-deploy");
+  console.log("The guarded command installs the exact candidate in the private state root, updates the same-name Worker, verifies candidate relay readiness, replaces the login daemon, verifies the background handoff, and exits while the service remains active.");
+  console.log("After activation, the coding agent derives the activated package root from the activation record runtime_entry and runs its packaged canary as direct Node argv from this repository cwd:");
+  console.log("node <activated-runtime-package>/scripts/release-oauth-canary.mjs --allow-live-oauth-canary");
+  console.log("For prereleases, the workspace script and npm lifecycle forms are source/developer paths only: they receive ordinary accounting and fail runtime-provenance evidence because the executing package must match activation runtime_entry.");
+  console.log("Only after the canary and observed live verification succeed does the coding agent record acceptance with:");
   console.log(`npm run release:accept -- --confirm \"${phrase}\"`);
   console.log("Automated tests alone do not authorize acceptance or the first GitHub push.");
 }
 
-function recordAcceptance() {
+function recordAcceptance(npmCli) {
   const pkg = readPackage();
   const supplied = argumentValue("--confirm");
   const expected = confirmationPhrase(pkg.name, pkg.version);
   if (supplied !== expected) {
-    throw new Error(`interactive candidate verification confirmation must exactly match: ${expected}`);
-  }
-  const pending = readJson(candidateManifestPath, "release candidate manifest");
-  if (pending.result !== "pending" || pending.package_name !== pkg.name || pending.package_version !== pkg.version) {
-    throw new Error("release candidate manifest does not match the current package");
+    throw new Error(`candidate verification confirmation must exactly match: ${expected}`);
   }
+  const pending = validateCandidateManifest(readJson(candidateManifestPath, "release candidate manifest"), {
+    packageName: pkg.name,
+    packageVersion: pkg.version,
+  });
   verifyTarball(join(candidateDirectory, pending.filename), pending);
+  readReleaseOAuthCanaryEvidence(root, {
+    package_name: pending.package_name,
+    package_version: pending.package_version,
+    shasum: pending.shasum,
+    integrity: pending.integrity,
+    promotion_content_sha256: pending.promotion_content_sha256,
+  });
 
   const verificationDirectory = join(candidateDirectory, "verification");
-  rmSync(verificationDirectory, { recursive: true, force: true });
+  rmSync(verificationDirectory, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
   mkdirSync(verificationDirectory, { recursive: true });
-  const current = packProject(root, verificationDirectory);
+  const current = packProject(root, verificationDirectory, { npmCli, env: process.env });
   for (const key of ["package_name", "package_version", "filename", "shasum", "integrity"]) {
     if (pending[key] !== current[key]) {
       throw new Error(`source changed after candidate preparation: ${key} no longer matches`);
     }
   }
 
+  const promotionDigest = computePromotionContentDigest(root, { npmCli });
+  if (pending.promotion_content_sha256 !== promotionDigest) {
+    throw new Error("source changed after candidate preparation: promotion content digest no longer matches");
+  }
+
   const record = {
     schema_version: ACCEPTANCE_SCHEMA_VERSION,
     result: "passed",
@@ -94,18 +139,19 @@ function recordAcceptance() {
     shasum: current.shasum,
     integrity: current.integrity,
     accepted_at: new Date().toISOString(),
-    package_content_sha256: computePortablePackageDigest(),
+    package_content_sha256: computePortablePackageDigest(npmCli),
+    promotion_content_sha256: promotionDigest,
   };
   verifyAcceptanceRecord(record, current);
   const path = acceptancePath(root, pkg.version);
   mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(record, null, 2)}\n`, "utf8");
-  console.log(`Interactive local candidate acceptance recorded: ${path}`);
+  replaceFileAtomicallySync(path, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o644 });
+  console.log(`Local candidate acceptance recorded: ${path}`);
   console.log("Commit this record with the candidate. Any packaged-file change invalidates it.");
 }
 
-function verifyAcceptance() {
-  const result = verifyCurrentReleaseAcceptance(root);
+function verifyAcceptance(npmCli) {
+  const result = verifyCurrentReleaseAcceptance(root, { npmCli, env: process.env });
   if (!result.required) {
     console.log(`Local release acceptance is not required for ${result.version}.`);
     return;
@@ -113,18 +159,22 @@ function verifyAcceptance() {
   console.log(`Local release acceptance matches ${result.metadata.filename} (${result.metadata.shasum}).`);
 }
 
-function computePortablePackageDigest() {
-  const npmCli = process.env.npm_execpath;
-  if (!npmCli) throw new Error("portable package digest requires npm_execpath");
+function computePortablePackageDigest(npmCli) {
+  if (!npmCli) throw new Error("portable package digest requires a hardened npm CLI");
   const temporary = mkdtempSync(join(tmpdir(), "mbm-release-index-"));
   const indexPath = join(temporary, "index");
-  const env = { ...process.env, GIT_INDEX_FILE: indexPath };
+  const env = { ...nestedNpmEnvironment(process.env), GIT_INDEX_FILE: indexPath };
+  let digest = "";
+  let primaryError = null;
   try {
-    runChecked("git", ["read-tree", "HEAD"], { env });
-    runChecked("git", ["add", "--all", "--", "."], { env });
+    runChecked(git, ["read-tree", "HEAD"], { env });
+    runChecked(git, ["add", "--all", "--", "."], { env });
     const packed = runChecked(process.execPath, [
       npmCli,
       "pack",
+      "--workspaces=false",
+      "--global=false",
+      "--prefix", root,
       "--ignore-scripts",
       "--silent",
       "--dry-run",
@@ -134,12 +184,20 @@ function computePortablePackageDigest() {
       join(root, ".github", "scripts", "verify-release-acceptance.mjs"),
       "--print-digest",
     ], { env, input: packed.stdout });
-    const digest = verifier.stdout.trim();
+    digest = verifier.stdout.trim();
     if (!/^[0-9a-f]{64}$/.test(digest)) throw new Error("portable package digest output is invalid");
-    return digest;
-  } finally {
-    rmSync(temporary, { recursive: true, force: true });
+  } catch (error) {
+    primaryError = error;
+  }
+  let cleanupError = null;
+  try { rmSync(temporary, { recursive: true, force: true }); }
+  catch (error) { cleanupError = error; }
+  if (primaryError && cleanupError) {
+    throw new AggregateError([primaryError, cleanupError], "portable package digest failed and temporary cleanup was incomplete");
   }
+  if (primaryError) throw primaryError;
+  if (cleanupError) throw cleanupError;
+  return digest;
 }
 
 function runChecked(file, args, { env = process.env, input } = {}) {
@@ -148,12 +206,12 @@ function runChecked(file, args, { env = process.env, input } = {}) {
     encoding: "utf8",
     env,
     input,
+    timeout: 5 * 60 * 1000,
+    killSignal: "SIGKILL",
+    maxBuffer: 32 * 1024 * 1024,
     windowsHide: true,
   });
-  if (result.error) throw result.error;
-  if (result.status !== 0) {
-    throw new Error(`${file} ${args[0] || ""} failed: ${String(result.stderr || result.stdout).trim()}`);
-  }
+  if (result.error || result.status !== 0) throw new Error(releaseCommandFailure(file, args, result));
   return result;
 }
 
@@ -181,6 +239,6 @@ function confirmationPhrase(name, version) {
 }
 
 function fail(message) {
-  console.error(`local release acceptance failed: ${message}`);
+  console.error(JSON.stringify(releaseDiagnosticEvent("release.acceptance.failed", message, 1200)));
   process.exit(1);
 }