@yeaft/webchat-agent 1.0.385 → 1.0.387

package/local-runtime/server/sandbox-agent-auth.js

@@ -1,66 +0,0 @@
-import { sandboxDb } from './database.js';
-import { agents } from './context.js';
-
-function readClaims(message) {
-  const claims = message?.sandboxClaims;
-  if (!claims || typeof claims !== 'object') return null;
-  if (typeof claims.sandboxId !== 'string' || typeof claims.instanceId !== 'string'
-    || !Number.isInteger(claims.generation) || typeof claims.imageDigest !== 'string') {
-    return null;
-  }
-  return claims;
-}
-
-/**
- * Authenticate a managed Sandbox Agent without accepting the user's general
- * Agent secret. URL identity and credential scope must describe the same
- * immutable Sandbox instance.
- */
-export function authenticateSandboxAgent(message, pending, store = sandboxDb) {
-  if (message?.authKind !== 'sandbox' || typeof message.credentialId !== 'string'
-    || typeof message.secret !== 'string') {
-    return null;
-  }
-  const claims = readClaims(message);
-  if (!claims || pending.instanceId !== claims.instanceId || pending.agentId !== claims.sandboxId) {
-    return null;
-  }
-  try {
-    const authenticated = store.authenticateCredential(message.credentialId, message.secret, claims);
-    if (authenticated.sandboxId !== claims.sandboxId) return null;
-    return {
-      ...authenticated,
-      instanceId: claims.instanceId,
-      generation: claims.generation,
-      imageDigest: claims.imageDigest,
-      sessionKey: message.secret
-    };
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Resolve readiness from the authenticated managed Agent connection. Controller
- * booleans are inspection evidence, but cannot prove that the scoped Agent has
- * completed its end-to-end Server sync.
- */
-export function canForceReadyAfterSyncTimeout(agent) {
-  return !agent?.sandboxIdentity;
-}
-
-export function isSandboxAgentReady(identity, connectedAgents = agents) {
-  if (!identity) return false;
-  for (const agent of connectedAgents.values()) {
-    const current = agent.sandboxIdentity;
-    if (agent.status === 'ready' && agent.isAlive && current
-      && current.sandboxId === identity.sandboxId
-      && agent.instanceId === identity.instanceId
-      && current.generation === identity.generation
-      && current.imageDigest === identity.imageDigest
-      && agent.capabilities?.includes('managed-sandbox')) {
-      return true;
-    }
-  }
-  return false;
-}

package/local-runtime/server/sandbox-attestation-listener.js

@@ -1,128 +0,0 @@
-import express from 'express';
-import { createServer } from 'https';
-import { CONFIG } from './config.js';
-import {
-  authenticateSandboxController,
-  handleSandboxHostAttestation
-} from './routes/sandbox-routes.js';
-
-export const SANDBOX_HOST_ATTESTATION_PATH = '/api/sandbox/hosts/attest';
-
-function authenticatePeer(req, res, next, config) {
-  if (!authenticateSandboxController(req, config.controllerAttestationFingerprint)) {
-    return res.status(401).json({ code: 'SANDBOX_CONTROLLER_IDENTITY_REJECTED' });
-  }
-  return next();
-}
-
-function parseStrictJson(req, res, next) {
-  try {
-    const body = JSON.parse(req.body.toString('utf8'));
-    if (!body || typeof body !== 'object') {
-      return res.status(400).json({ code: 'SANDBOX_ATTESTATION_BODY_INVALID' });
-    }
-    req.body = body;
-    return next();
-  } catch {
-    return res.status(400).json({ code: 'SANDBOX_ATTESTATION_BODY_INVALID' });
-  }
-}
-
-function bodyErrorHandler(err, req, res, next) {
-  if (!err) return next();
-  if (err.type === 'entity.too.large') {
-    return res.status(413).json({ code: 'SANDBOX_ATTESTATION_BODY_TOO_LARGE' });
-  }
-  return next(err);
-}
-
-/**
- * Create the dedicated HTTPS server used only for Controller Host attestation.
- * TLS chain authorization occurs before Express, while the route also pins the
- * leaf certificate fingerprint before consuming the signed payload.
- *
- * @param {{ config?: object, handler?: Function }} options
- * @returns {import('https').Server}
- */
-export function createSandboxAttestationListener({
-  config = CONFIG.sandbox,
-  handler = handleSandboxHostAttestation
-} = {}) {
-  const app = express();
-  app.disable('x-powered-by');
-
-  app.post(
-    SANDBOX_HOST_ATTESTATION_PATH,
-    (req, res, next) => authenticatePeer(req, res, next, config),
-    express.raw({ limit: config.hostAttestationBodyLimitBytes, type: () => true }),
-    parseStrictJson,
-    (req, res) => handler(req, res, config)
-  );
-  app.use(bodyErrorHandler);
-
-  const listener = createServer({
-    cert: config.hostAttestationServerCert,
-    key: config.hostAttestationServerKey,
-    ca: config.hostAttestationClientCa,
-    requestCert: true,
-    rejectUnauthorized: true,
-    minVersion: 'TLSv1.2'
-  }, app);
-  const sockets = new Set();
-  listener.on('connection', socket => {
-    sockets.add(socket);
-    socket.once('close', () => sockets.delete(socket));
-  });
-  listener.sandboxAttestationSockets = sockets;
-  listener.sandboxAttestationShutdownTimeoutMs = config.hostAttestationShutdownTimeoutMs;
-  return listener;
-}
-
-/**
- * Start the attestation listener when Managed Sandbox is enabled.
- * @param {{ config?: object, handler?: Function }} options
- * @returns {Promise<import('https').Server|null>}
- */
-export async function startSandboxAttestationListener({
-  config = CONFIG.sandbox,
-  handler = handleSandboxHostAttestation
-} = {}) {
-  if (!config.enabled) return null;
-  const listener = createSandboxAttestationListener({ config, handler });
-  await new Promise((resolve, reject) => {
-    const onError = (err) => {
-      listener.off('listening', onListening);
-      reject(err);
-    };
-    const onListening = () => {
-      listener.off('error', onError);
-      resolve();
-    };
-    listener.once('error', onError);
-    listener.once('listening', onListening);
-    listener.listen(config.hostAttestationListenerPort, config.hostAttestationListenerHost);
-  });
-  return listener;
-}
-
-export async function closeSandboxAttestationListener(listener) {
-  if (!listener) return;
-  const sockets = listener.sandboxAttestationSockets || new Set();
-  const timeoutMs = listener.sandboxAttestationShutdownTimeoutMs || 1_000;
-  await new Promise((resolve, reject) => {
-    let settled = false;
-    const finish = err => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      if (err && err.code !== 'ERR_SERVER_NOT_RUNNING') reject(err);
-      else resolve();
-    };
-    const timer = setTimeout(() => {
-      for (const socket of sockets) socket.destroy();
-    }, timeoutMs);
-    timer.unref?.();
-    listener.close(finish);
-    listener.closeIdleConnections?.();
-  });
-}

package/local-runtime/server/sandbox-config.js

@@ -1,42 +0,0 @@
-/**
- * Existing Sandbox cleanup needs only the Controller trust and transport configuration.
- * It deliberately does not depend on the product admission flag or creation-only settings.
- * @param {object} config
- * @returns {boolean}
- */
-export function validateSandboxCleanupConfig(config) {
-  if (!config?.controllerUrl || !config.controllerToken
-    || !config.operationSigningPrivateKey || !config.controllerResultPublicKey
-    || !config.controllerHostId || !config.helperAttestationPublicKey
-    || !config.controllerClientCert || !config.controllerClientKey
-    || !config.controllerCaCert) return false;
-  try {
-    return new URL(config.controllerUrl).protocol === 'https:';
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Sandbox execution is allowed only through a fully configured dedicated HTTPS Controller.
- * The current mixed-use Server Host is never an implicit execution target.
- * @param {object} config
- * @returns {boolean}
- */
-export function validateSandboxDeploymentConfig(config) {
-  if (!config?.enabled || !validateSandboxCleanupConfig(config)
-    || !config.bootstrapSigningKey
-    || !config.hostAttestationKey || !config.controllerAttestationFingerprint
-    || !config.hostAttestationListenerHost
-    || !Number.isSafeInteger(config.hostAttestationListenerPort)
-    || config.hostAttestationListenerPort <= 0
-    || config.hostAttestationListenerPort > 65_535
-    || !config.hostAttestationServerCert || !config.hostAttestationServerKey
-    || !config.hostAttestationClientCa
-    || !Number.isSafeInteger(config.hostAttestationBodyLimitBytes)
-    || config.hostAttestationBodyLimitBytes <= 0
-    || !config.imageDigest
-    || !Number.isSafeInteger(config.hostMemoryReserveMiB)
-    || config.hostMemoryReserveMiB <= 0) return false;
-  return true;
-}

package/local-runtime/server/sandbox-host-attestation.js

@@ -1,175 +0,0 @@
-import { createHmac, timingSafeEqual } from 'crypto';
-import db, { transaction } from './db/connection.js';
-
-const HEALTH_FIELDS = Object.freeze([
-  'controllerHealthy',
-  'helperHealthy',
-  'runtimeHealthy',
-  'quotaHealthy',
-  'networkHealthy'
-]);
-
-export class SandboxHostAttestationError extends Error {
-  constructor(code) {
-    super(code);
-    this.code = code;
-  }
-}
-
-function canonicalPayload(attestation) {
-  return JSON.stringify({
-    hostId: attestation.hostId,
-    epoch: attestation.epoch,
-    nonce: attestation.nonce,
-    observedAt: attestation.observedAt,
-    imageDigest: attestation.imageDigest,
-    resources: attestation.resources,
-    checks: attestation.checks
-  });
-}
-
-function validIdentifier(value, maxLength = 128) {
-  return typeof value === 'string' && value.length > 0 && value.length <= maxLength
-    && /^[a-zA-Z0-9._:-]+$/.test(value);
-}
-
-function verifySignature(payload, signature, key) {
-  if (!key || typeof signature !== 'string') return false;
-  const expected = createHmac('sha256', key).update(payload).digest();
-  let actual;
-  try {
-    actual = Buffer.from(signature, 'base64url');
-  } catch {
-    return false;
-  }
-  return actual.length === expected.length && timingSafeEqual(actual, expected);
-}
-
-function validateAttestation(attestation, config, now) {
-  if (!attestation || !validIdentifier(attestation.hostId) || !validIdentifier(attestation.epoch)
-    || !validIdentifier(attestation.nonce, 192) || !validIdentifier(attestation.imageDigest, 192)) {
-    throw new SandboxHostAttestationError('SANDBOX_HOST_ATTESTATION_INVALID');
-  }
-  if (attestation.hostId !== config.controllerHostId
-    || attestation.imageDigest !== config.imageDigest) {
-    throw new SandboxHostAttestationError('SANDBOX_HOST_ATTESTATION_SCOPE_MISMATCH');
-  }
-  const observedAt = Number(attestation.observedAt);
-  if (!Number.isSafeInteger(observedAt)
-    || Math.abs(now - observedAt) > config.hostAttestationMaxSkewMs) {
-    throw new SandboxHostAttestationError('SANDBOX_HOST_ATTESTATION_STALE');
-  }
-  const resources = attestation.resources || {};
-  if (![resources.cpuMillis, resources.memoryMiB, resources.memoryAvailableMiB, resources.diskGiB]
-    .every(value => Number.isSafeInteger(value) && value > 0)
-    || resources.memoryAvailableMiB > resources.memoryMiB) {
-    throw new SandboxHostAttestationError('SANDBOX_HOST_ATTESTATION_INVALID');
-  }
-  if (!verifySignature(canonicalPayload(attestation), attestation.signature, config.hostAttestationKey)) {
-    throw new SandboxHostAttestationError('SANDBOX_HOST_ATTESTATION_INVALID');
-  }
-  return Boolean(attestation.checks)
-    && HEALTH_FIELDS.every(field => attestation.checks[field] === true);
-}
-
-function appendAudit(attestation, outcome, errorCode, now) {
-  db.prepare(`
-    INSERT INTO sandbox_host_audit_events (
-      host_id, epoch, event_type, outcome, error_code, created_at
-    ) VALUES (?, ?, 'qualification_attested', ?, ?, ?)
-  `).run(
-    String(attestation?.hostId || 'invalid').slice(0, 128),
-    String(attestation?.epoch || 'invalid').slice(0, 128),
-    outcome,
-    errorCode,
-    now
-  );
-}
-
-export function registerSandboxHostAttestation(attestation, config, now = Date.now()) {
-  try {
-    const qualified = validateAttestation(attestation, config, now);
-    return transaction(() => {
-      const prior = db.prepare('SELECT nonce FROM sandbox_host_attestations WHERE nonce = ?')
-        .get(attestation.nonce);
-      if (prior) throw new SandboxHostAttestationError('SANDBOX_HOST_ATTESTATION_REPLAYED');
-
-      const latest = db.prepare(`
-        SELECT observed_at FROM sandbox_host_attestations
-        WHERE host_id = ? ORDER BY observed_at DESC LIMIT 1
-      `).get(attestation.hostId);
-      if (latest && Number(attestation.observedAt) <= latest.observed_at) {
-        throw new SandboxHostAttestationError('SANDBOX_HOST_ATTESTATION_OUT_OF_ORDER');
-      }
-
-      const priorEpoch = db.prepare(`
-        SELECT source_epoch, epoch FROM sandbox_host_epochs WHERE host_id = ?
-      `).get(attestation.hostId);
-      const allocatedEpoch = priorEpoch
-        ? priorEpoch.epoch + Number(priorEpoch.source_epoch !== attestation.epoch)
-        : 1;
-      const { resources, checks } = attestation;
-      db.prepare(`
-        INSERT INTO sandbox_hosts (
-          id, epoch, qualified, controller_healthy, helper_healthy, runtime_healthy,
-          quota_healthy, network_healthy, image_digest, cpu_millis_total,
-          memory_mib_total, memory_mib_available, disk_gib_total, updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        ON CONFLICT(id) DO UPDATE SET
-          epoch = excluded.epoch,
-          qualified = excluded.qualified,
-          controller_healthy = excluded.controller_healthy,
-          helper_healthy = excluded.helper_healthy,
-          runtime_healthy = excluded.runtime_healthy,
-          quota_healthy = excluded.quota_healthy,
-          network_healthy = excluded.network_healthy,
-          image_digest = excluded.image_digest,
-          cpu_millis_total = excluded.cpu_millis_total,
-          memory_mib_total = excluded.memory_mib_total,
-          memory_mib_available = excluded.memory_mib_available,
-          disk_gib_total = excluded.disk_gib_total,
-          updated_at = excluded.updated_at
-      `).run(
-        attestation.hostId, allocatedEpoch, Number(qualified),
-        Number(checks.controllerHealthy), Number(checks.helperHealthy),
-        Number(checks.runtimeHealthy), Number(checks.quotaHealthy), Number(checks.networkHealthy),
-        attestation.imageDigest, resources.cpuMillis, resources.memoryMiB,
-        resources.memoryAvailableMiB, resources.diskGiB, now
-      );
-      db.prepare(`
-        INSERT INTO sandbox_host_epochs
-          (host_id, source_epoch, epoch, activation_digest, activated_at, updated_at)
-        VALUES (?, ?, ?, NULL, NULL, ?)
-        ON CONFLICT(host_id) DO UPDATE SET
-          source_epoch = excluded.source_epoch,
-          epoch = excluded.epoch,
-          activation_digest = CASE
-            WHEN sandbox_host_epochs.epoch = excluded.epoch
-              THEN sandbox_host_epochs.activation_digest ELSE NULL END,
-          activated_at = CASE
-            WHEN sandbox_host_epochs.epoch = excluded.epoch
-              THEN sandbox_host_epochs.activated_at ELSE NULL END,
-          updated_at = excluded.updated_at
-      `).run(attestation.hostId, attestation.epoch, allocatedEpoch, now);
-      db.prepare(`
-        INSERT INTO sandbox_host_attestations (nonce, host_id, epoch, observed_at, created_at)
-        VALUES (?, ?, ?, ?, ?)
-      `).run(attestation.nonce, attestation.hostId, allocatedEpoch, attestation.observedAt, now);
-      appendAudit(
-        { ...attestation, epoch: allocatedEpoch },
-        qualified ? 'accepted' : 'rejected',
-        qualified ? null : 'SANDBOX_HOST_NOT_QUALIFIED',
-        now
-      );
-      return { accepted: true, qualified, epoch: allocatedEpoch };
-    })();
-  } catch (error) {
-    const code = error instanceof SandboxHostAttestationError
-      ? error.code
-      : 'SANDBOX_HOST_ATTESTATION_INVALID';
-    appendAudit(attestation, 'rejected', code, now);
-    throw error instanceof SandboxHostAttestationError
-      ? error
-      : new SandboxHostAttestationError(code);
-  }
-}