enigma-memory 0.1.18 → 0.1.22

package/scripts/bootstrap-enigma.mjs

@@ -0,0 +1,502 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { access, chmod, mkdir, mkdtemp, open, readFile, rm } from 'node:fs/promises';
+import { homedir, tmpdir } from 'node:os';
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { validateNodeVersion } from './install-enigma-local.mjs';
+
+export const BOOTSTRAP_SCHEMA = 'enigma.bootstrap.v1';
+export const DEFAULT_LAUNCH = 'desktop';
+
+const SCRIPT_PATH = fileURLToPath(import.meta.url);
+const DEFAULT_PACKAGE_DIR = resolve(dirname(SCRIPT_PATH), '..');
+const CONTROL_CHARACTER_RE = /[\0\n\r]/u;
+
+function readRequiredValue(argv, index, flag) {
+  const value = argv[index + 1];
+  if (value === undefined || value.startsWith('--')) throw new Error(`Missing value for ${flag}.`);
+  return value;
+}
+
+function rejectUnsafeValue(value, label) {
+  const text = String(value ?? '');
+  if (text.length === 0) throw new Error(`${label} must not be empty.`);
+  if (CONTROL_CHARACTER_RE.test(text)) throw new Error(`${label} contains an invalid control character.`);
+  return text;
+}
+
+export function usage() {
+  return `Install the complete Enigma harness, create an encrypted local vault, and open the desktop.\n\nUsage:\n  npx --yes enigma-memory@latest\n  enigma-memory [--desktop|--terminal|--no-launch] [--bundle <path>] [--passphrase-file <path>] [--prefix <path>] [--dry-run]\n\nDefaults:\n  - Installs the exact package executing this bootstrap.\n  - Creates ~/.enigma/passphrase with cryptographically random bytes when no vault exists.\n  - Creates ~/.enigma/bundle.json with encrypted key custody.\n  - Opens enigma-desktop with lexical embeddings, avoiding a first-run neural model download.\n\nExisting vaults are never overwritten. If a bundle exists without its passphrase file, bootstrap fails closed.\n`;
+}
+
+export function parseBootstrapArgs(argv = process.argv.slice(2)) {
+  const options = {
+    dryRun: false,
+    initialize: true,
+    launch: DEFAULT_LAUNCH,
+  };
+  let launchSelection;
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+    } else if (arg === '--dry-run') {
+      options.dryRun = true;
+    } else if (arg === '--desktop') {
+      if (launchSelection && launchSelection !== 'desktop') throw new Error('Choose one launch mode.');
+      launchSelection = 'desktop';
+      options.launch = 'desktop';
+    } else if (arg === '--terminal') {
+      if (launchSelection && launchSelection !== 'terminal') throw new Error('Choose one launch mode.');
+      launchSelection = 'terminal';
+      options.launch = 'terminal';
+    } else if (arg === '--no-launch') {
+      if (launchSelection && launchSelection !== 'none') throw new Error('Choose one launch mode.');
+      launchSelection = 'none';
+      options.launch = 'none';
+    } else if (arg === '--no-init') {
+      options.initialize = false;
+    } else if (arg === '--bundle') {
+      options.bundlePath = readRequiredValue(argv, index, arg);
+      index += 1;
+    } else if (arg === '--passphrase-file') {
+      options.passphraseFile = readRequiredValue(argv, index, arg);
+      index += 1;
+    } else if (arg === '--prefix') {
+      options.prefix = readRequiredValue(argv, index, arg);
+      index += 1;
+    } else {
+      throw new Error(`Unknown bootstrap argument: ${arg}`);
+    }
+  }
+
+  return options;
+}
+
+function npmRuntime(runtime, platform) {
+  const nodeCommand = resolve(runtime.nodeCommand ?? process.execPath);
+  const npmCliPath = runtime.npmCliPath
+    ?? process.env.npm_execpath
+    ?? (platform === 'win32' ? join(dirname(nodeCommand), 'node_modules', 'npm', 'bin', 'npm-cli.js') : undefined);
+  return npmCliPath
+    ? { command: nodeCommand, argsPrefix: [resolve(npmCliPath)] }
+    : { command: 'npm', argsPrefix: [] };
+}
+
+function resolveRequestedPath(value, fallback, cwd) {
+  const requested = rejectUnsafeValue(value ?? fallback, 'Bootstrap path');
+  return isAbsolute(requested) ? resolve(requested) : resolve(cwd, requested);
+}
+
+export function buildBootstrapPlan(options = {}, runtime = {}) {
+  const platform = runtime.platform ?? process.platform;
+  const cwd = runtime.cwd ?? process.cwd();
+  const home = runtime.homeDir ?? homedir();
+  const packageDir = resolve(rejectUnsafeValue(runtime.packageDir ?? DEFAULT_PACKAGE_DIR, 'Package directory'));
+  const enigmaDir = resolve(runtime.enigmaDir ?? join(home, '.enigma'));
+  const bundlePath = resolveRequestedPath(options.bundlePath, join(enigmaDir, 'bundle.json'), cwd);
+  const passphraseFile = resolveRequestedPath(options.passphraseFile, join(enigmaDir, 'passphrase'), cwd);
+  const prefix = options.prefix === undefined ? undefined : resolveRequestedPath(options.prefix, options.prefix, cwd);
+  const archiveDir = runtime.archiveDir ?? '<temporary-pack-directory>';
+  const npm = npmRuntime(runtime, platform);
+  const npmArgs = (args) => [...npm.argsPrefix, ...args];
+  const installArgs = ['install', '--global', '<packed-tarball>'];
+  const globalRootArgs = ['root', '--global'];
+  if (prefix) {
+    installArgs.push('--prefix', prefix);
+    globalRootArgs.push('--prefix', prefix);
+  }
+  return {
+    schema: BOOTSTRAP_SCHEMA,
+    platform,
+    nodeCommand: resolve(runtime.nodeCommand ?? process.execPath),
+    packageDir,
+    bundlePath,
+    passphraseFile,
+    prefix,
+    dryRun: options.dryRun === true,
+    initialize: options.initialize !== false,
+    launch: options.launch ?? DEFAULT_LAUNCH,
+    archiveDir,
+    commands: {
+      pack: { command: npm.command, args: npmArgs(['pack', packageDir, '--json', '--pack-destination', archiveDir]), cwd: packageDir },
+      install: { command: npm.command, args: npmArgs(installArgs), cwd: packageDir },
+      globalRoot: { command: npm.command, args: npmArgs(globalRootArgs), cwd: packageDir },
+    },
+  };
+}
+
+export function installedHarnessCommands(plan, globalRoot) {
+  const root = rejectUnsafeValue(String(globalRoot ?? '').trim(), 'npm global root');
+  if (!isAbsolute(root)) throw new Error('npm global root must be absolute.');
+  const installedPackageDir = join(resolve(root), 'enigma-memory');
+  const entry = (path) => join(installedPackageDir, path);
+  return {
+    installedPackageDir,
+    version: {
+      command: plan.nodeCommand,
+      args: [entry('apps/cli/bin/enigma.mjs'), '--version'],
+      cwd: installedPackageDir,
+    },
+    setup: {
+      command: plan.nodeCommand,
+      args: [entry('apps/cli/bin/enigma.mjs'), 'setup', '--bundle', plan.bundlePath, '--out-dir', dirname(plan.bundlePath), '--passphrase-file', plan.passphraseFile],
+      cwd: installedPackageDir,
+    },
+    desktop: {
+      command: plan.nodeCommand,
+      args: [entry('apps/cli/bin/enigma-desktop.mjs'), '--bundle', plan.bundlePath, '--passphrase-file', plan.passphraseFile, '--embedding-model', 'lexical'],
+      cwd: installedPackageDir,
+    },
+    terminal: {
+      command: plan.nodeCommand,
+      args: [entry('apps/cli/bin/enigma-terminal.mjs'), '--bundle', plan.bundlePath],
+      cwd: installedPackageDir,
+    },
+  };
+}
+
+async function fileExists(path, accessImpl = access) {
+  try {
+    await accessImpl(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function windowsSidFromWhoami(stdout) {
+  const sid = String(stdout ?? '').match(/\bS-\d-(?:\d+-)+\d+\b/u)?.[0];
+  if (!sid) throw new Error('Unable to resolve the current Windows user SID.');
+  return sid;
+}
+
+
+function windowsSystemTools(runtime = {}) {
+  const systemRoot = rejectUnsafeValue(
+    runtime.windowsSystemRoot ?? process.env.SystemRoot ?? process.env.WINDIR,
+    'Windows system root',
+  );
+  if (!isAbsolute(systemRoot)) throw new Error('Windows system root must be absolute.');
+  const system32 = join(systemRoot, 'System32');
+  return {
+    system32,
+    whoami: join(system32, 'whoami.exe'),
+    powershell: join(system32, 'WindowsPowerShell', 'v1.0', 'powershell.exe'),
+  };
+}
+
+async function currentWindowsUserSid(runCommand, runtime) {
+  const tools = windowsSystemTools(runtime);
+  const whoami = await runCommand({
+    command: tools.whoami,
+    args: ['/user', '/fo', 'csv', '/nh'],
+    cwd: tools.system32,
+  }, { capture: true, step: 'resolve_windows_user' });
+  return windowsSidFromWhoami(whoami.stdout);
+}
+
+const WINDOWS_VERIFY_CURRENT_USER_ACL_SCRIPT = [
+  "$ErrorActionPreference = 'Stop'",
+  '$path = $env:ENIGMA_BOOTSTRAP_ACL_PATH',
+  '$expectedSid = [System.Security.Principal.SecurityIdentifier]::new($env:ENIGMA_BOOTSTRAP_ACL_SID)',
+  '$sections = [System.Security.AccessControl.AccessControlSections]::Access -bor [System.Security.AccessControl.AccessControlSections]::Owner',
+  '$acl = [System.IO.File]::GetAccessControl($path, $sections)',
+  '$owner = $acl.GetOwner([System.Security.Principal.SecurityIdentifier])',
+  '$rules = @($acl.GetAccessRules($true, $true, [System.Security.Principal.SecurityIdentifier]))',
+  '$valid = $owner.Value -eq $expectedSid.Value -and $acl.AreAccessRulesProtected -and $rules.Count -eq 1',
+  'if ($valid) { $rule = $rules[0]; $valid = -not $rule.IsInherited -and $rule.IdentityReference.Value -eq $expectedSid.Value -and $rule.AccessControlType -eq [System.Security.AccessControl.AccessControlType]::Allow -and $rule.FileSystemRights -eq [System.Security.AccessControl.FileSystemRights]::FullControl -and $rule.InheritanceFlags -eq [System.Security.AccessControl.InheritanceFlags]::None -and $rule.PropagationFlags -eq [System.Security.AccessControl.PropagationFlags]::None }',
+  "if (-not $valid) { throw 'Windows passphrase ACL is not current-user-only.' }",
+  '[Console]::Out.WriteLine($expectedSid.Value)',
+].join('; ');
+
+async function verifyWindowsPassphraseAclForSid(path, sid, runCommand, runtime) {
+  const tools = windowsSystemTools(runtime);
+  let verification;
+  try {
+    verification = await runCommand({
+      command: tools.powershell,
+      args: ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', WINDOWS_VERIFY_CURRENT_USER_ACL_SCRIPT],
+      cwd: tools.system32,
+    }, {
+      capture: true,
+      step: 'verify_passphrase_acl',
+      env: {
+        ...process.env,
+        ENIGMA_BOOTSTRAP_ACL_PATH: path,
+        ENIGMA_BOOTSTRAP_ACL_SID: sid,
+      },
+    });
+  } catch (error) {
+    throw new Error(`Windows passphrase ACL is not current-user-only: ${String(error?.message ?? error)}`);
+  }
+  if (windowsSidFromWhoami(verification.stdout) !== sid) {
+    throw new Error('Windows passphrase ACL verification returned a different SID.');
+  }
+  return { verified: true, sid, ace_count: 1 };
+}
+
+export async function verifyWindowsPassphraseAcl(path, runtime = {}) {
+  const runCommand = runtime.runAclCommand ?? defaultRunCommand;
+  const sid = await currentWindowsUserSid(runCommand, runtime);
+  return verifyWindowsPassphraseAclForSid(path, sid, runCommand, runtime);
+}
+
+const WINDOWS_CREATE_CURRENT_USER_PASSPHRASE_SCRIPT = [
+  "$ErrorActionPreference = 'Stop'",
+  '$path = $env:ENIGMA_BOOTSTRAP_ACL_PATH',
+  '$sid = [System.Security.Principal.WindowsIdentity]::GetCurrent().User',
+  '$acl = [System.Security.AccessControl.FileSecurity]::new()',
+  '$acl.SetOwner($sid)',
+  '$acl.SetAccessRuleProtection($true, $false)',
+  '$rule = [System.Security.AccessControl.FileSystemAccessRule]::new($sid, [System.Security.AccessControl.FileSystemRights]::FullControl, [System.Security.AccessControl.AccessControlType]::Allow)',
+  '$acl.SetAccessRule($rule)',
+  '$created = $false',
+  'try { $stream = [System.IO.FileStream]::new($path, [System.IO.FileMode]::CreateNew, [System.Security.AccessControl.FileSystemRights]::Write, [System.IO.FileShare]::None, 4096, [System.IO.FileOptions]::WriteThrough, $acl); $created = $true; try { [Console]::OpenStandardInput().CopyTo($stream); $stream.Flush($true) } finally { $stream.Dispose() }; [Console]::Out.WriteLine($sid.Value) } catch { if ($created) { [System.IO.File]::Delete($path) }; throw }',
+].join('; ');
+
+async function createWindowsPassphraseFile(path, secret, runtime = {}) {
+  const runCommand = runtime.runAclCommand ?? defaultRunCommand;
+  const tools = windowsSystemTools(runtime);
+  const creation = await runCommand({
+    command: tools.powershell,
+    args: ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', WINDOWS_CREATE_CURRENT_USER_PASSPHRASE_SCRIPT],
+    cwd: tools.system32,
+  }, {
+    capture: true,
+    input: Buffer.from(secret, 'utf8'),
+    step: 'create_secure_passphrase',
+    env: {
+      ...process.env,
+      ENIGMA_BOOTSTRAP_ACL_PATH: path,
+    },
+  });
+  const sid = windowsSidFromWhoami(creation.stdout);
+  try {
+    return await verifyWindowsPassphraseAclForSid(path, sid, runCommand, runtime);
+  } catch (error) {
+    await (runtime.rmImpl ?? rm)(path, { force: true });
+    throw error;
+  }
+}
+
+export async function ensureBootstrapPassphrase(plan, runtime = {}) {
+  const accessImpl = runtime.accessImpl ?? access;
+  const bundleExists = await fileExists(plan.bundlePath, accessImpl);
+  const passphraseExists = await fileExists(plan.passphraseFile, accessImpl);
+  if (bundleExists && !passphraseExists) {
+    throw new Error('An Enigma bundle already exists but its passphrase file is missing. Refusing to generate a replacement credential.');
+  }
+
+  const chmodImpl = runtime.chmodImpl ?? chmod;
+  if (passphraseExists) {
+    if (plan.platform === 'win32') {
+      try {
+        const acl = await verifyWindowsPassphraseAcl(plan.passphraseFile, runtime);
+        return { created: false, bundleExists, acl_verified: acl.verified };
+      } catch (error) {
+        throw new Error(`The existing Windows passphrase file is not current-user-only: ${String(error?.message ?? error)}`);
+      }
+    }
+    await chmodImpl(plan.passphraseFile, 0o600);
+    return { created: false, bundleExists };
+  }
+
+  const mkdirImpl = runtime.mkdirImpl ?? mkdir;
+  const randomBytesImpl = runtime.randomBytesImpl ?? randomBytes;
+  await mkdirImpl(dirname(plan.passphraseFile), { recursive: true });
+  const secret = `${randomBytesImpl(32).toString('base64')}\n`;
+  if (plan.platform === 'win32') {
+    try {
+      const acl = await createWindowsPassphraseFile(plan.passphraseFile, secret, runtime);
+      return { created: true, bundleExists, acl_verified: acl.verified };
+    } catch (error) {
+      throw new Error(`Unable to atomically create the generated Windows passphrase file: ${String(error?.message ?? error)}`);
+    }
+  }
+
+  const openImpl = runtime.openImpl ?? open;
+  const rmImpl = runtime.rmImpl ?? rm;
+  let passphraseHandle;
+  try {
+    passphraseHandle = await openImpl(plan.passphraseFile, 'wx', 0o600);
+  } catch (error) {
+    if (error?.code === 'EEXIST') {
+      throw new Error('The passphrase file appeared during bootstrap. Refusing to use an unverified credential.');
+    }
+    throw error;
+  }
+  try {
+    await chmodImpl(plan.passphraseFile, 0o600);
+    await passphraseHandle.writeFile(secret, { encoding: 'utf8' });
+    await passphraseHandle.sync();
+    await chmodImpl(plan.passphraseFile, 0o600);
+    await passphraseHandle.close();
+    passphraseHandle = undefined;
+    return { created: true, bundleExists };
+  } catch (error) {
+    if (passphraseHandle) await passphraseHandle.close().catch(() => {});
+    await rmImpl(plan.passphraseFile, { force: true });
+    throw error;
+  }
+}
+
+export function installerFailureCode(stderr) {
+  const match = String(stderr ?? '').match(/npm\s+(?:error|ERR!)\s+code\s+([A-Z0-9_-]+)/iu);
+  return match?.[1]?.toUpperCase();
+}
+
+async function defaultRunCommand(spec, options = {}) {
+  const capture = options.capture === true;
+  const hasInput = options.input !== undefined;
+  const child = spawn(spec.command, spec.args, {
+    cwd: spec.cwd,
+    env: options.env ?? process.env,
+    shell: false,
+    windowsHide: true,
+    stdio: capture
+      ? [hasInput ? 'pipe' : 'ignore', 'pipe', 'pipe']
+      : (hasInput ? ['pipe', 'inherit', 'inherit'] : 'inherit'),
+  });
+  let stdout = '';
+  let stderr = '';
+  if (capture) {
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+  }
+  const exitPromise = new Promise((resolveExit, rejectExit) => {
+    child.once('error', rejectExit);
+    child.once('exit', (code) => resolveExit(code ?? 1));
+  });
+  if (hasInput) {
+    child.stdin.on('error', () => {});
+    child.stdin.end(options.input);
+  }
+  const exitCode = await exitPromise;
+  if (exitCode !== 0) {
+    const failureCode = installerFailureCode(stderr);
+    throw new Error(`Bootstrap command failed: ${options.step ?? 'unknown'}${failureCode ? ` (${failureCode})` : ''}.`);
+  }
+  return { exitCode, stdout, stderr };
+}
+
+export function packedTarballPath(stdout, archiveDir) {
+  let records;
+  try {
+    records = JSON.parse(String(stdout ?? ''));
+  } catch {
+    throw new Error('npm pack did not return valid JSON.');
+  }
+  const filename = records?.[0]?.filename;
+  if (typeof filename !== 'string' || basename(filename) !== filename || !filename.endsWith('.tgz')) {
+    throw new Error('npm pack returned an unsafe archive filename.');
+  }
+  return join(archiveDir, filename);
+}
+
+function publicPlan(plan) {
+  return {
+    schema: plan.schema,
+    ok: true,
+    mode: plan.dryRun ? 'dry-run' : 'execute',
+    package_source: 'currently executing package',
+    install_scope: plan.prefix ? 'explicit_prefix' : 'global_npm_prefix',
+    initialize_vault: plan.initialize,
+    launch: plan.launch,
+    encrypted: plan.initialize,
+    generated_credential: plan.initialize ? 'secure local passphrase file when absent' : null,
+    neural_model_download_required: false,
+    commands: ['install harness', 'verify enigma command', ...(plan.initialize ? ['initialize encrypted vault'] : []), ...(plan.launch === 'none' ? [] : [`launch ${plan.launch}`])],
+  };
+}
+
+export async function runBootstrap(argv = process.argv.slice(2), runtime = {}) {
+  const options = Array.isArray(argv) ? parseBootstrapArgs(argv) : { ...argv };
+  if (options.help) return { help: usage() };
+  validateNodeVersion(runtime.nodeVersion ?? process.versions.node);
+  const mkdtempImpl = runtime.mkdtempImpl ?? mkdtemp;
+  const archiveDir = options.dryRun === true
+    ? undefined
+    : await mkdtempImpl(join(runtime.tempDir ?? tmpdir(), 'enigma-bootstrap-'));
+  const plan = buildBootstrapPlan(options, { ...runtime, archiveDir });
+  if (plan.dryRun) return publicPlan(plan);
+
+  const runCommand = runtime.runCommand ?? defaultRunCommand;
+  let credential = { created: false, bundleExists: false };
+  if (plan.initialize) credential = await ensureBootstrapPassphrase(plan, runtime);
+
+  const rmImpl = runtime.rmImpl ?? rm;
+  try {
+    const packResult = await runCommand(plan.commands.pack, { capture: true, step: 'pack_harness' });
+    const tarball = packedTarballPath(packResult.stdout, plan.archiveDir);
+    const installSpec = {
+      ...plan.commands.install,
+      args: plan.commands.install.args.map((arg) => arg === '<packed-tarball>' ? tarball : arg),
+    };
+    await runCommand(installSpec, { capture: true, step: 'install_harness' });
+  } finally {
+    await rmImpl(plan.archiveDir, { recursive: true, force: true });
+  }
+  const globalRootResult = await runCommand(plan.commands.globalRoot, { capture: true, step: 'resolve_global_root' });
+  const harnessCommands = installedHarnessCommands(plan, globalRootResult.stdout);
+  const versionResult = await runCommand(harnessCommands.version, { capture: true, step: 'verify_install' });
+  const readFileImpl = runtime.readFileImpl ?? readFile;
+  const packageJson = JSON.parse(await readFileImpl(join(plan.packageDir, 'package.json'), 'utf8'));
+  if (!String(versionResult.stdout ?? '').includes(String(packageJson.version))) {
+    throw new Error('Installed Enigma version could not be verified.');
+  }
+
+  if (plan.initialize && !credential.bundleExists) {
+    await runCommand(harnessCommands.setup, { capture: true, step: 'initialize_vault' });
+    if (!(await fileExists(plan.bundlePath, runtime.accessImpl ?? access))) throw new Error('Enigma setup completed without creating the bundle.');
+  }
+
+  const result = {
+    ...publicPlan(plan),
+    mode: 'execute',
+    installed: true,
+    vault_initialized: plan.initialize,
+    passphrase_created: credential.created,
+    existing_bundle_reused: credential.bundleExists,
+  };
+
+  if (plan.launch === 'desktop') {
+    await runCommand(harnessCommands.desktop, { capture: false, step: 'launch_desktop' });
+  } else if (plan.launch === 'terminal') {
+    const passphrase = (await readFileImpl(plan.passphraseFile, 'utf8')).trim();
+    await runCommand(harnessCommands.terminal, {
+      capture: false,
+      step: 'launch_terminal',
+      env: { ...process.env, ENIGMA_PASSPHRASE: passphrase },
+    });
+  }
+  return result;
+}
+
+function renderResult(result) {
+  if (result.help) return result.help;
+  if (result.mode === 'dry-run') return `${JSON.stringify(result, null, 2)}\n`;
+  return [
+    'Enigma harness installed.',
+    result.existing_bundle_reused ? 'Existing encrypted vault preserved.' : 'Encrypted local vault ready.',
+    result.launch === 'none' ? 'Run enigma-terminal or enigma-desktop to begin.' : `${result.launch === 'desktop' ? 'Desktop' : 'Terminal'} session closed. Run it again at any time.`,
+  ].join('\n') + '\n';
+}
+
+async function main() {
+  try {
+    const result = await runBootstrap();
+    process.stdout.write(renderResult(result));
+  } catch (error) {
+    process.stderr.write(`Enigma bootstrap failed: ${String(error?.message ?? error)}\n`);
+    process.exitCode = 1;
+  }
+}
+
+if (resolve(process.argv[1] ?? '') === SCRIPT_PATH) await main();

package/scripts/build-edge-backend-workers.mjs

@@ -52,9 +52,9 @@ export const EDGE_BACKEND_REF_ENV_NAMES = Object.freeze({
   gateway_deployment: Object.freeze(['ENIGMA_GATEWAY_DEPLOYMENT_REF']),
 });
 const CLAIM_BOUNDARY = Object.freeze([
-  'Edge backend Workers provide public HTTPS liveness/readiness and fail-closed private-route boundaries for urgent bootstrap only.',
-  'Readiness is true only when operator-supplied evidence refs and operator acceptance are configured; the Worker does not create storage, KMS, SIEM, backups, legal approval, or acceptance evidence.',
-  'Private data-plane routes remain closed by default; raw memory, prompts, transcripts, provider responses, credentials, and private keys must not be returned by these Workers.',
+  'Edge backend Workers provide public HTTPS liveness/readiness for urgent bootstrap only; hosted_backend_live is always false.',
+  'Bootstrap readiness covers operator-supplied refs and binding checks, but the Worker does not implement the relay/gateway runtime or prove production readiness.',
+  'The private data plane is closed and non-operational; raw memory, prompts, transcripts, provider responses, credentials, and private keys must not be returned by these Workers.',
 ]);
 
 const SECRET_VALUE_RE = /(?:Bearer\s+[A-Za-z0-9._~+/=-]{12,}|Basic\s+[A-Za-z0-9+/=-]{12,}|-----BEGIN [A-Z ]*PRIVATE KEY-----|https?:\/\/[^\s/@]+:[^\s/@]+@|sk-[A-Za-z0-9_-]{16,}|AKIA[0-9A-Z]{16})/iu;
@@ -98,6 +98,12 @@ const REQUIRED_REFS = ${requiredRefs};
 const REF_ENV_NAMES = ${refEnvNames};
 const PRIVATE_ROUTES = ${privateRoutes};
 const CLAIM_BOUNDARY = ${boundary};
+const RUNTIME_CAPABILITY = Object.freeze({
+  marker: 'enigma.private_data_plane.runtime.v1',
+  bootstrap_worker: true,
+  private_data_plane_operational: false,
+  authenticated_data_plane_supported: false
+});
 
 function json(body, status = 200) {
   return new Response(JSON.stringify(body, null, 2), {
@@ -194,6 +200,9 @@ async function readiness(env) {
     service_kind: SERVICE_KIND,
     runtime: 'cloudflare-workers',
     generated_at: GENERATED_AT,
+    hosted_backend_live: false,
+    private_data_plane_operational: false,
+    runtime_capability: RUNTIME_CAPABILITY,
     status: ok ? 'ready' : 'blocked',
     evidence_refs: refs,
     evidence_ref_count: configured.length,
@@ -210,7 +219,7 @@ async function readiness(env) {
 }
 
 function error(code, message) {
-  return { ok: false, service: SERVICE_NAME, error: { code, message }, claim_boundary: CLAIM_BOUNDARY };
+  return { ok: false, service: SERVICE_NAME, hosted_backend_live: false, private_data_plane_operational: false, runtime_capability: RUNTIME_CAPABILITY, error: { code, message }, claim_boundary: CLAIM_BOUNDARY };
 }
 
 function plaintextLooking(value, seen = new WeakSet()) {
@@ -239,7 +248,7 @@ export default {
   async fetch(request, env) {
     const url = new URL(request.url);
     if (request.method !== 'GET' && request.method !== 'HEAD' && request.method !== 'POST') return json(error('METHOD_NOT_ALLOWED', 'Only GET, HEAD, and POST are allowed.'), 405);
-    if (url.pathname === '/livez') return json({ ok: true, service: SERVICE_NAME, service_kind: SERVICE_KIND, runtime: 'cloudflare-workers', claim_boundary: CLAIM_BOUNDARY });
+    if (url.pathname === '/livez') return json({ ok: true, service: SERVICE_NAME, service_kind: SERVICE_KIND, runtime: 'cloudflare-workers', hosted_backend_live: false, private_data_plane_operational: false, runtime_capability: RUNTIME_CAPABILITY, claim_boundary: CLAIM_BOUNDARY });
     if (url.pathname === '/readyz') {
       const body = await readiness(env);
       return json(body, body.ok ? 200 : 503);
@@ -264,6 +273,10 @@ export function validateEdgeBackendWorkerSource(source, configInput) {
   if (!text.includes("url.pathname === '/readyz'")) blockers.push({ path: 'source.readyz', message: 'worker must route /readyz' });
   if (!text.includes('PRIVATE_ROUTE_CLOSED')) blockers.push({ path: 'source.private_routes', message: 'worker must fail closed for private routes' });
   if (text.includes('hosted_probe_only') || text.includes('pages_edge_probe_only')) blockers.push({ path: 'source.claim', message: 'edge backend worker must not masquerade as probe-only payload' });
+  if (!text.includes('hosted_backend_live: false')) blockers.push({ path: 'source.claim', message: 'bootstrap worker must explicitly declare hosted_backend_live false' });
+  if (!text.includes('private_data_plane_operational: false')) blockers.push({ path: 'source.capability', message: 'bootstrap worker must explicitly declare the private data plane non-operational' });
+  if (!text.includes('authenticated_data_plane_supported: false')) blockers.push({ path: 'source.capability', message: 'bootstrap worker must explicitly declare authenticated data-plane support unavailable' });
+  if (/hosted_backend_live\s*:\s*true/u.test(text)) blockers.push({ path: 'source.claim', message: 'bootstrap worker must never declare hosted_backend_live true' });
   if (SECRET_VALUE_RE.test(text)) blockers.push({ path: 'source.secret', message: 'worker source contains secret-looking literal' });
   for (const key of REQUIRED_REF_KEYS) if (!text.includes(key)) blockers.push({ path: `source.refs.${key}`, message: `worker source missing ${key}` });
   return {
@@ -286,6 +299,8 @@ export function buildEdgeBackendWorkerBundle(options = {}) {
       hostname: `${config.hostPrefix}.${domain}`,
       default_routes: ['/livez', '/readyz'],
       private_routes: [...config.privateRoutes],
+      hosted_backend_live: false,
+      private_data_plane_operational: false,
       validation: validateEdgeBackendWorkerSource(source, config),
       files: {
         'worker.mjs': source,