@yeaft/webchat-agent 1.0.385 → 1.0.387

package/local-runtime/server/db/user-db.js

@@ -1,50 +1,6 @@
-import { createHash, randomUUID } from 'crypto';
+import { randomUUID } from 'crypto';
 import db, { stmts, generateUserId, generateAgentSecret, transaction } from './connection.js';
 
-function deletionRequestDigest() {
-  return createHash('sha256').update(JSON.stringify({ kind: 'remove' })).digest('hex');
-}
-
-function ensureDeletionRemoval(userId, deletionId, now = Date.now()) {
-  const sandbox = db.prepare('SELECT * FROM sandboxes WHERE user_id = ? AND reservation_held = 1').get(userId);
-  if (!sandbox) return null;
-  const baseKey = `account-delete:${deletionId}`;
-  const attempts = db.prepare(`
-    SELECT * FROM sandbox_operations
-    WHERE user_id = ? AND (idempotency_key = ? OR idempotency_key LIKE ?)
-    ORDER BY created_at DESC, rowid DESC
-  `).all(userId, baseKey, `${baseKey}:attempt:%`);
-  const latest = attempts[0];
-  if (latest && latest.status !== 'failed') return latest;
-  const key = attempts.length === 0 ? baseKey : `${baseKey}:attempt:${attempts.length + 1}`;
-  const existing = db.prepare('SELECT * FROM sandbox_operations WHERE user_id = ? AND idempotency_key = ?')
-    .get(userId, key);
-  if (existing) return existing;
-  db.prepare(`
-    UPDATE sandbox_operations SET status = 'failed', error_code = 'ACCOUNT_DELETION_REQUESTED', updated_at = ?
-    WHERE sandbox_id = ? AND status IN ('pending', 'running')
-  `).run(now, sandbox.id);
-  db.prepare('UPDATE sandbox_credentials SET revoked_at = ? WHERE sandbox_id = ? AND revoked_at IS NULL')
-    .run(now, sandbox.id);
-  const host = db.prepare('SELECT epoch FROM sandbox_hosts WHERE id = ?').get(sandbox.host_id);
-  const hostEpoch = host?.epoch || sandbox.host_epoch;
-  const generation = sandbox.generation + 1;
-  db.prepare(`
-    UPDATE sandboxes SET desired_state = 'removed', observed_state = CASE
-      WHEN observed_state = 'removed' THEN observed_state ELSE 'recovery_required' END,
-      generation = ?, host_epoch = ?, last_error_code = NULL, updated_at = ?
-    WHERE id = ? AND reservation_held = 1
-  `).run(generation, hostEpoch, now, sandbox.id);
-  const operationId = `sandbox_op_${randomUUID()}`;
-  db.prepare(`
-    INSERT INTO sandbox_operations (
-      id, sandbox_id, user_id, idempotency_key, request_digest, kind, status,
-      stage, generation, host_epoch, deadline_at, created_at, updated_at
-    ) VALUES (?, ?, ?, ?, ?, 'remove', 'pending', 'removing', ?, ?, ?, ?, ?)
-  `).run(operationId, sandbox.id, userId, key, deletionRequestDigest(), generation,
-    hostEpoch, now + 10 * 60_000, now, now);
-  return db.prepare('SELECT * FROM sandbox_operations WHERE id = ?').get(operationId);
-}
 
 export const userDb = {
   getOrCreate(username, displayName = null) {
@@ -116,44 +72,17 @@ export const userDb = {
             password_hash = NULL, agent_secret = NULL, totp_secret = NULL, totp_enabled = 0
           WHERE id = ? AND deletion_state = 'active'
         `).run(now, deletionId, userId);
-        if (changed.changes !== 1) {
-          throw new Error('ACCOUNT_DELETION_STATE_CONFLICT');
-        }
+        if (changed.changes !== 1) throw new Error('ACCOUNT_DELETION_STATE_CONFLICT');
       }
-      db.prepare('UPDATE sandbox_entitlements SET enabled = 0, updated_at = ? WHERE user_id = ?')
-        .run(now, userId);
-      const operation = ensureDeletionRemoval(userId, deletionId, now);
-      return { deletionId, status: 'pending', operationId: operation?.id || null };
+      return { deletionId, status: 'pending', operationId: null };
     })();
   },
 
-  reconcilePendingDeletions(now = Date.now()) {
-    const pending = db.prepare("SELECT id, deletion_id FROM users WHERE deletion_state = 'pending'").all();
+  reconcilePendingDeletions() {
+    const pending = db.prepare("SELECT id FROM users WHERE deletion_state = 'pending'").all();
     let finalized = 0;
     for (const user of pending) {
-      if (stmts.getReservedSandboxForUser.get(user.id)) {
-        transaction(() => ensureDeletionRemoval(user.id, user.deletion_id, now))();
-        continue;
-      }
-      const unsettled = db.prepare(`
-        SELECT 1 FROM sandboxes s
-        WHERE s.user_id = ? AND (
-          s.observed_state != 'removed' OR s.removed_at IS NULL
-          OR EXISTS (
-            SELECT 1 FROM sandbox_operations o
-            WHERE o.sandbox_id = s.id AND o.status IN ('pending', 'running')
-          )
-          OR NOT EXISTS (
-            SELECT 1 FROM sandbox_operations o
-            WHERE o.sandbox_id = s.id AND o.kind = 'remove' AND o.status = 'succeeded'
-          )
-          OR EXISTS (
-            SELECT 1 FROM sandbox_credentials c
-            WHERE c.sandbox_id = s.id AND c.revoked_at IS NULL
-          )
-        ) LIMIT 1
-      `).get(user.id);
-      if (!unsettled && this.deleteUser(user.id, { requirePending: true })) finalized++;
+      if (this.deleteUser(user.id, { requirePending: true })) finalized++;
     }
     return finalized;
   },
@@ -255,33 +184,17 @@ export const userDb = {
    * session store from here to keep this layer pure).
    */
   deleteUser(userId, { requirePending = false } = {}) {
-    // Final erasure is allowed only after every Sandbox reservation has settled.
     const run = transaction((id) => {
       const user = stmts.getUserById.get(id);
       if (!user || (requirePending && user.deletion_state !== 'pending')) return false;
-      if (stmts.getReservedSandboxForUser.get(id)) {
-        const error = new Error('SANDBOX_REMOVE_REQUIRED');
-        error.code = 'SANDBOX_REMOVE_REQUIRED';
-        throw error;
-      }
-      if (requirePending) {
-        const unsettled = db.prepare(`
-          SELECT 1 FROM sandboxes s WHERE s.user_id = ? AND (
-            s.observed_state != 'removed' OR s.removed_at IS NULL
-            OR EXISTS (SELECT 1 FROM sandbox_operations o WHERE o.sandbox_id = s.id AND o.status IN ('pending', 'running'))
-            OR NOT EXISTS (SELECT 1 FROM sandbox_operations o WHERE o.sandbox_id = s.id AND o.kind = 'remove' AND o.status = 'succeeded')
-            OR EXISTS (SELECT 1 FROM sandbox_credentials c WHERE c.sandbox_id = s.id AND c.revoked_at IS NULL)
-          ) LIMIT 1
-        `).get(id);
-        if (unsettled) return false;
-      }
-      stmts.deleteReleasedSandboxesForUser.run(id);
+
       stmts.deleteIdentitiesForUser.run(id);
       stmts.deleteUserSessionsByUser.run(id);
       stmts.deleteYeaftSessionsByUserCascade.run(id);
       stmts.deleteUserStats.run(id);
       stmts.deleteDailyStatsForUser.run(id);
       stmts.deleteCustomExpertRolesForUser.run(id);
+      stmts.deleteLegacySandboxesForUser.run(id);
       stmts.deleteInvitationsCreatedBy.run(id);
       stmts.clearInvitationUsedBy.run(id);
       if (requirePending) {

package/local-runtime/server/index.js

@@ -16,11 +16,6 @@ import { handleAgentConnection } from './ws-agent.js';
 import { handleWebConnection } from './ws-client.js';
 import { sendToWebClient } from './ws-utils.js';
 import { markAgentHeartbeatPing, markAgentHeartbeatStall, shouldTerminateAgentHeartbeat } from './heartbeat-policy.js';
-import { createSandboxReconciler } from './sandbox-reconciler.js';
-import {
-  closeSandboxAttestationListener,
-  startSandboxAttestationListener
-} from './sandbox-attestation-listener.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -227,8 +222,6 @@ if (configValidation.warnings) {
   console.warn('');
 }
 
-let sandboxReconcileTimer = null;
-let sandboxAttestationListener = null;
 const accountDeletionTimer = setInterval(() => {
   try {
     userDb.reconcilePendingDeletions();
@@ -240,32 +233,20 @@ accountDeletionTimer.unref?.();
 userDb.reconcilePendingDeletions();
 
 async function startServers() {
-  sandboxAttestationListener = await startSandboxAttestationListener({ config: CONFIG.sandbox });
-  if (sandboxAttestationListener) {
-    console.log(`Sandbox Host attestation listener running on https://${CONFIG.sandbox.hostAttestationListenerHost}:${CONFIG.sandbox.hostAttestationListenerPort}`);
-  }
-
-  try {
-    await new Promise((resolve, reject) => {
-      const onError = (err) => {
-        server.off('listening', onListening);
-        reject(err);
-      };
-      const onListening = () => {
-        server.off('error', onError);
-        resolve();
-      };
-      server.once('error', onError);
-      server.once('listening', onListening);
-      server.listen(CONFIG.port, CONFIG.host);
-    });
-  } catch (err) {
-    await closeSandboxAttestationListener(sandboxAttestationListener);
-    sandboxAttestationListener = null;
-    throw err;
-  }
+  await new Promise((resolve, reject) => {
+    const onError = (err) => {
+      server.off('listening', onListening);
+      reject(err);
+    };
+    const onListening = () => {
+      server.off('error', onError);
+      resolve();
+    };
+    server.once('error', onError);
+    server.once('listening', onListening);
+    server.listen(CONFIG.port, CONFIG.host);
+  });
 
-  sandboxReconcileTimer = createSandboxReconciler({ config: CONFIG.sandbox }).start();
   console.log(`Server running on http://${CONFIG.host || '0.0.0.0'}:${CONFIG.port}`);
   console.log(`Auth mode: ${CONFIG.skipAuth ? 'SKIP (development)' : 'ENABLED'}`);
   if (!CONFIG.skipAuth) {
@@ -276,7 +257,6 @@ async function startServers() {
 
 startServers().catch(err => {
   console.error('[Startup] Failed to start server:', err);
-  if (sandboxReconcileTimer) clearInterval(sandboxReconcileTimer);
   process.exit(1);
 });
 
@@ -285,14 +265,7 @@ startServers().catch(err => {
 // =====================
 async function gracefulShutdown(signal) {
   console.log(`\n[Shutdown] Received ${signal}, starting graceful shutdown...`);
-  if (sandboxReconcileTimer) clearInterval(sandboxReconcileTimer);
   clearInterval(accountDeletionTimer);
-  try {
-    await closeSandboxAttestationListener(sandboxAttestationListener);
-    if (sandboxAttestationListener) console.log('[Shutdown] Sandbox attestation listener closed');
-  } catch (err) {
-    console.error('[Shutdown] Failed to close Sandbox attestation listener:', err.message);
-  }
 
   // 1. 通知所有 web client 服务即将更新
   const updateMsg = { type: 'server_updating' };

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

@@ -1,123 +1,56 @@
-import { timingSafeEqual } from 'crypto';
-import { CONFIG } from '../config.js';
-import { sandboxDb, userDb } from '../database.js';
-import { SandboxConflictError } from '../db/sandbox-db.js';
-import {
-  registerSandboxHostAttestation,
-  SandboxHostAttestationError
-} from '../sandbox-host-attestation.js';
+import { userDb } from '../database.js';
+import { containerAgentService } from '../container-agent-service.js';
 
 function loadUser(req) {
   let user = userDb.getByUsername(req.user.username);
-  if (!user && CONFIG.skipAuth) user = userDb.getOrCreate(req.user.username, req.user.username);
+  if (!user && req.user.username === 'dev-user') user = userDb.getOrCreate('dev-user', 'dev-user');
   return user;
 }
 
-function sendError(res, err) {
-  if (err instanceof SandboxConflictError) {
-    return res.status(409).json({ code: err.code });
-  }
-  console.error('Sandbox API error:', err);
-  return res.status(500).json({ code: 'SANDBOX_INTERNAL_ERROR' });
-}
-
-function normalizedFingerprint(value) {
-  return String(value || '').replaceAll(':', '').trim().toLowerCase();
-}
-
-export function authenticateSandboxController(request, expectedFingerprint) {
-  if (!request?.socket?.authorized) return false;
-  const expected = Buffer.from(normalizedFingerprint(expectedFingerprint));
-  const certificate = request.socket.getPeerCertificate?.();
-  const actual = Buffer.from(normalizedFingerprint(certificate?.fingerprint256));
-  return expected.length > 0 && expected.length === actual.length
-    && timingSafeEqual(expected, actual);
-}
-
-export function handleSandboxHostAttestation(req, res, config = CONFIG.sandbox) {
-  if (!authenticateSandboxController(req, config.controllerAttestationFingerprint)) {
-    return res.status(401).json({ code: 'SANDBOX_CONTROLLER_IDENTITY_REJECTED' });
-  }
-  try {
-    registerSandboxHostAttestation(req.body, config);
-    return res.status(202).json({ accepted: true });
-  } catch (err) {
-    if (err instanceof SandboxHostAttestationError) {
-      return res.status(401).json({ code: 'SANDBOX_HOST_ATTESTATION_REJECTED' });
-    }
-    return sendError(res, err);
-  }
+function sendError(res, error) {
+  const code = error.code || error.message || 'SANDBOX_INTERNAL_ERROR';
+  const known = code.startsWith('SANDBOX_') || code.startsWith('CONTAINER_AGENT_');
+  if (!known) console.error('Container Agent API error:', error);
+  return res.status(known ? 409 : 500).json({ code: known ? code : 'SANDBOX_INTERNAL_ERROR' });
 }
 
-export function registerSandboxRoutes(app, { requireAuth, requireAdmin }) {
-  // The managed runtime has no user Agent secret. Its one-time bootstrap token
-  // is itself the scoped authorization for obtaining a revocable credential.
-  app.post('/api/sandbox/bootstrap/exchange', (req, res) => {
-    try {
-      const result = sandboxDb.exchangeBootstrap(req.body?.token, req.body?.claims);
-      return res.json(result);
-    } catch (err) {
-      if (err instanceof SandboxConflictError) {
-        return res.status(401).json({ code: 'SANDBOX_BOOTSTRAP_INVALID' });
-      }
-      return sendError(res, err);
-    }
-  });
-
-  app.put('/api/admin/sandbox/entitlements/:userId', requireAuth, requireAdmin, (req, res) => {
-    try {
-      const entitlement = sandboxDb.setEntitlement(
-        req.params.userId,
-        req.body?.enabled,
-        req.user?.username
-      );
-      return res.json({ entitlement });
-    } catch (err) {
-      if (err instanceof SandboxConflictError && err.code === 'SANDBOX_USER_NOT_FOUND') {
-        return res.status(404).json({ code: err.code });
-      }
-      return sendError(res, err);
-    }
-  });
-
-  app.get('/api/sandbox/capability', requireAuth, (req, res) => {
-    const user = loadUser(req);
-    if (!user) return res.status(404).json({ code: 'USER_NOT_FOUND' });
-    res.json(sandboxDb.capability(user.id, CONFIG.sandbox));
+export function registerSandboxRoutes(app, { requireAuth }) {
+  app.get('/api/sandbox/capability', requireAuth, (_req, res) => {
+    res.json(containerAgentService.capability());
   });
 
-  app.get('/api/sandbox', requireAuth, (req, res) => {
+  app.get('/api/sandbox', requireAuth, async (req, res) => {
     const user = loadUser(req);
     if (!user) return res.status(404).json({ code: 'USER_NOT_FOUND' });
-    res.json({ sandbox: sandboxDb.snapshot(user.id) });
+    try {
+      return res.json({ sandbox: await containerAgentService.snapshot(user.id) });
+    } catch (error) {
+      return sendError(res, error);
+    }
   });
 
-  app.post('/api/sandbox', requireAuth, (req, res) => {
+  app.post('/api/sandbox', requireAuth, async (req, res) => {
     const user = loadUser(req);
     if (!user) return res.status(404).json({ code: 'USER_NOT_FOUND' });
     try {
-      const result = sandboxDb.create(user.id, {
+      const agentSecret = userDb.getAgentSecret(user.id) || userDb.resetAgentSecret(user.id);
+      const result = await containerAgentService.create({ ...user, agent_secret: agentSecret }, {
         agentName: req.body?.agentName,
-        sizeId: req.body?.sizeId,
-        idempotencyKey: req.get('Idempotency-Key')
-      }, CONFIG.sandbox);
-      return res.status(result.replayed ? 200 : 202).json(result);
-    } catch (err) {
-      return sendError(res, err);
+      });
+      return res.status(201).json(result);
+    } catch (error) {
+      return sendError(res, error);
     }
   });
 
   for (const action of ['start', 'stop', 'retry', 'remove']) {
-    app.post(`/api/sandbox/${action}`, requireAuth, (req, res) => {
+    app.post(`/api/sandbox/${action}`, requireAuth, async (req, res) => {
       const user = loadUser(req);
       if (!user) return res.status(404).json({ code: 'USER_NOT_FOUND' });
       try {
-        const result = sandboxDb.requestAction(
-          user.id, action, req.get('Idempotency-Key'), CONFIG.sandbox
-        );
-        return res.status(result.replayed ? 200 : 202).json(result);
-      } catch (err) {
-        return sendError(res, err);
+        return res.json(await containerAgentService.action(user.id, action));
+      } catch (error) {
+        return sendError(res, error);
       }
     });
   }

package/local-runtime/server/routes/user-routes.js

@@ -7,6 +7,7 @@ import {
 } from '../auth/session-store.js';
 import { clearSessionCookie } from '../auth/request-auth.js';
 import { agents, webClients, userStatsDeltas } from '../context.js';
+import { containerAgentService } from '../container-agent-service.js';
 
 // 过滤用户敏感字段
 function sanitizeUser(user) {
@@ -154,6 +155,9 @@ export function registerUserRoutes(app, { requireAuth, requireAdmin }) {
         }
       }
 
+      // Remove the Server-managed container before deleting the owner record.
+      // Manually launched remote container Agents remain outside Server lifecycle control.
+      await containerAgentService.action(user.id, 'remove');
       const deletion = userDb.beginDeletion(user.id);
       if (!deletion) return res.status(404).json({ error: 'User not found or already deleted' });
 

package/local-runtime/server/ws-agent.js

@@ -2,7 +2,7 @@ import { randomUUID } from 'crypto';
 import { WebSocket } from 'ws';
 import { CONFIG } from './config.js';
 import { verifyAgent } from './auth.js';
-import { authenticateSandboxAgent, canForceReadyAfterSyncTimeout } from './sandbox-agent-auth.js';
+
 import { encodeKey } from './encryption.js';
 import { agents, pendingAgentConnections } from './context.js';
 import { userDb } from './database.js';
@@ -104,15 +104,11 @@ export function handleAgentConnection(ws, url) {
           clearTimeout(pending.timeout);
           pendingAgentConnections.delete(tempId);
 
-          const sandboxAuth = !skipAgentAuth && msg.authKind === 'sandbox'
-            ? authenticateSandboxAgent(msg, pending)
-            : null;
-          const authResult = sandboxAuth
-            || (msg.authKind
-              ? { valid: false, sessionKey: null, userId: null, username: null }
-              : skipAgentAuth
-                ? { valid: true, sessionKey: null, userId: null, username: null }
-                : verifyAgent(msg.secret));
+          const authResult = msg.authKind
+            ? { valid: false, sessionKey: null, userId: null, username: null }
+            : skipAgentAuth
+              ? { valid: true, sessionKey: null, userId: null, username: null }
+              : verifyAgent(msg.secret);
           if (!authResult.valid) {
             pruneAgentConnectionGenerations();
             console.log(`Agent auth failed: ${agentName}`);
@@ -122,21 +118,15 @@ export function handleAgentConnection(ws, url) {
 
           const capabilities = Array.isArray(msg.capabilities) ? msg.capabilities : urlCapabilities;
           const agentVersion = msg.version || null;
-          if (sandboxAuth && !capabilities.includes('managed-sandbox')) {
-            pruneAgentConnectionGenerations();
-            ws.close(1008, 'Invalid Sandbox Agent capability');
-            return;
-          }
           // Local no-auth mode still has one durable browser owner. This makes
           // the server-side Session catalog persistent without changing generic
           // development-server behavior, which remains ownerless.
           const localOwner = skipAgentAuth && process.env.YEAFT_LOCAL_RUN === 'true'
             ? userDb.getOrCreate('dev-user')
             : null;
-          const ownerId = sandboxAuth?.userId || localOwner?.id || authResult.userId;
+          const ownerId = localOwner?.id || authResult.userId;
           const ownerUsername = localOwner?.username || authResult.username || null;
-          const registeredInstanceId = sandboxAuth?.instanceId
-            || pending.instanceId || pending.agentId || pending.agentName;
+          const registeredInstanceId = pending.instanceId || pending.agentId || pending.agentName;
           // Authenticated Agents use an owner-scoped key. SKIP_AUTH preserves
           // its historical unscoped id while still receiving version metadata.
           resolvedAgentId = skipAgentAuth
@@ -159,11 +149,6 @@ export function handleAgentConnection(ws, url) {
             ownerUsername,
             agentVersion,
             registeredInstanceId,
-            sandboxAuth ? {
-              sandboxId: sandboxAuth.sandboxId,
-              generation: sandboxAuth.generation,
-              imageDigest: sandboxAuth.imageDigest,
-            } : null,
           );
           pruneAgentConnectionGenerations();
         }
@@ -248,7 +233,7 @@ function handleAgentDisconnect(agentId, agentName, ws) {
   broadcastAgentList();
 }
 
-function completeAgentRegistration(ws, agentId, agentName, workDir, sessionKey, capabilities = [], ownerId = null, ownerUsername = null, agentVersion = null, instanceId = null, sandboxIdentity = null) {
+function completeAgentRegistration(ws, agentId, agentName, workDir, sessionKey, capabilities = [], ownerId = null, ownerUsername = null, agentVersion = null, instanceId = null) {
   // 如果是重连，保留 conversations；否则（server 重启）创建空 Map
   const existingAgent = agents.get(agentId);
   const conversations = existingAgent?.conversations || new Map();
@@ -285,13 +270,12 @@ function completeAgentRegistration(ws, agentId, agentName, workDir, sessionKey,
     ownerId,
     ownerUsername,
     version: agentVersion,
-    encryptOutbound,
-    sandboxIdentity
+    encryptOutbound
   });
 
   const syncTimeout = setTimeout(() => {
     const ag = agents.get(agentId);
-    if (ag?.ws === ws && ag.status === 'syncing' && canForceReadyAfterSyncTimeout(ag)) {
+    if (ag?.ws === ws && ag.status === 'syncing') {
       console.warn(`[Sync] Agent ${agentName} sync timeout, forcing ready`);
       ag.status = 'ready';
       broadcastAgentList();

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.385"}
+{"version":"1.0.387"}