@yeaft/webchat-agent 1.0.406 → 1.0.408

package/container-manager.js

@@ -91,6 +91,18 @@ export function buildCreateArgs({
   ];
 }
 
+/**
+ * Verify that the Docker client can reach a daemon before the Server advertises
+ * container Agent lifecycle support.
+ *
+ * @param {object} options runDocker overrides used by tests and alternate runtimes
+ * @returns {Promise<{serverVersion: string|null}>}
+ */
+export async function checkContainerAgentRuntime(options = {}) {
+  const result = await runDocker(['version', '--format', '{{.Server.Version}}'], options);
+  return { serverVersion: result.stdout || null };
+}
+
 export async function inspectContainerAgent(name, options = {}) {
   const result = await runDocker([
     'inspect', '--format', '{{json .State}}', containerNameForAgent(name),
@@ -139,15 +151,27 @@ export async function stopContainerAgent(name, runtime = {}) {
   return inspectContainerAgent(name, runtime);
 }
 
+function isMissingDockerVolume(stderr) {
+  return /no such volume/i.test(String(stderr || ''));
+}
+
 export async function removeContainerAgent(name, { removeVolumes = true, ...runtime } = {}) {
   const containerName = containerNameForAgent(name);
   const current = await inspectContainerAgent(name, runtime);
   if (current.exists) await runDocker(['rm', '-f', containerName], runtime);
   if (removeVolumes) {
-    await runDocker(['volume', 'rm', `${containerName}-data`, `${containerName}-workspace`], {
-      ...runtime,
-      allowFailure: true,
-    });
+    for (const volume of [`${containerName}-data`, `${containerName}-workspace`]) {
+      const result = await runDocker(['volume', 'rm', volume], {
+        ...runtime,
+        allowFailure: true,
+      });
+      if (result.code !== 0 && !isMissingDockerVolume(result.stderr)) {
+        throw new ContainerAgentError(
+          'CONTAINER_AGENT_DOCKER_FAILED',
+          result.stderr || `docker volume rm ${volume} failed`,
+        );
+      }
+    }
   }
   return { exists: false, status: 'absent', running: false };
 }

package/local-runtime/server/.env.example

@@ -44,6 +44,14 @@ EMAIL_CODE_EXPIRES_IN=300000
 # Agents must provide this secret to connect
 AGENT_SECRET=agent-shared-secret
 
+# Server-managed Sandbox (disabled by default)
+# Docker socket access is equivalent to Host root. For Docker Compose, use the
+# explicit docker-compose.sandbox.yml override documented in docs/operations/sandbox-agent.md.
+# SANDBOX_ENABLED=false
+# SANDBOX_SERVER_URL=wss://your-yeaft-server.example
+# SANDBOX_AGENT_IMAGE=ghcr.io/yeaft/yeaft-web-code-agent-agent:dev
+# SANDBOX_STATE_DIR=/var/lib/yeaft/container-agents
+
 # File upload settings
 MAX_FILE_SIZE=52428800
 FILE_CLEANUP_INTERVAL=600000

package/local-runtime/server/container-agent-service.js

@@ -1,6 +1,9 @@
+import { access, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { CONFIG } from './config.js';
+import { userDb } from './database.js';
 import {
+  checkContainerAgentRuntime,
   createContainerAgent,
   inspectContainerAgent,
   removeContainerAgent,
@@ -9,21 +12,62 @@ import {
   writeAgentSecretFile,
 } from '../agent/container-manager.js';
 
+const DEFAULT_RUNTIME = Object.freeze({
+  check: checkContainerAgentRuntime,
+  create: createContainerAgent,
+  inspect: inspectContainerAgent,
+  remove: removeContainerAgent,
+  start: startContainerAgent,
+  stop: stopContainerAgent,
+  writeSecret: writeAgentSecretFile,
+});
+
 function managedName(userId) {
   return `sandbox-${String(userId).replace(/[^a-zA-Z0-9_.-]/g, '-').slice(0, 48)}`;
 }
 
 export class ContainerAgentService {
-  constructor(config = CONFIG.sandbox) {
+  constructor(config = CONFIG.sandbox, runtime = DEFAULT_RUNTIME, ownerDb = userDb) {
     this.config = config;
+    this.runtime = runtime;
+    this.ownerDb = ownerDb;
+    this.ownerLifecycleTails = new Map();
   }
 
-  capability() {
-    return {
-      available: this.config.enabled,
-      reasonCode: this.config.enabled ? null : 'SANDBOX_DISABLED',
-      catalog: this.config.enabled ? [{ id: 'standard' }] : [],
-    };
+  async withOwnerLifecycle(userId, operation) {
+    const ownerKey = String(userId);
+    const previous = this.ownerLifecycleTails.get(ownerKey) || Promise.resolve();
+    let release;
+    const current = new Promise(resolve => { release = resolve; });
+    const tail = previous.catch(() => {}).then(() => current);
+    this.ownerLifecycleTails.set(ownerKey, tail);
+    await previous.catch(() => {});
+    try {
+      return await operation();
+    } finally {
+      release();
+      if (this.ownerLifecycleTails.get(ownerKey) === tail) {
+        this.ownerLifecycleTails.delete(ownerKey);
+      }
+    }
+  }
+
+  async capability() {
+    if (!this.config.enabled) {
+      return { available: false, reasonCode: 'SANDBOX_DISABLED', catalog: [] };
+    }
+    try {
+      await this.runtime.check();
+      return { available: true, reasonCode: null, catalog: [{ id: 'standard' }] };
+    } catch {
+      return { available: false, reasonCode: 'SANDBOX_DOCKER_UNAVAILABLE', catalog: [] };
+    }
+  }
+
+  assertEnabled() {
+    if (!this.config.enabled) {
+      throw Object.assign(new Error('SANDBOX_DISABLED'), { code: 'SANDBOX_DISABLED' });
+    }
   }
 
   nameForUser(userId) {
@@ -31,8 +75,9 @@ export class ContainerAgentService {
   }
 
   async snapshot(userId) {
+    if (!this.config.enabled) return null;
     const name = this.nameForUser(userId);
-    const state = await inspectContainerAgent(name);
+    const state = await this.runtime.inspect(name);
     if (!state.exists) return null;
     return {
       id: name,
@@ -46,32 +91,91 @@ export class ContainerAgentService {
     };
   }
 
-  async create(user, { agentName } = {}) {
-    if (!this.config.enabled) throw Object.assign(new Error('SANDBOX_DISABLED'), { code: 'SANDBOX_DISABLED' });
-    const name = this.nameForUser(user.id);
-    const secretFile = join(this.config.stateDir, name, 'agent-secret');
-    await writeAgentSecretFile(secretFile, user.agent_secret);
-    await createContainerAgent({
-      name,
-      serverUrl: this.config.serverUrl,
-      secretFile,
-      image: this.config.image,
+  async create(user) {
+    return this.withOwnerLifecycle(user.id, async () => {
+      await this.assertAvailable();
+      if (!this.ownerDb.isActive(user.id)) {
+        throw Object.assign(new Error('SANDBOX_OWNER_INACTIVE'), { code: 'SANDBOX_OWNER_INACTIVE' });
+      }
+      const name = this.nameForUser(user.id);
+      const secretFile = join(this.config.stateDir, name, 'agent-secret');
+      await this.runtime.writeSecret(secretFile, user.agent_secret);
+      await this.runtime.create({
+        name,
+        serverUrl: this.config.serverUrl,
+        secretFile,
+        image: this.config.image,
+      });
+      return { snapshot: await this.snapshot(user.id), replayed: false };
     });
-    return { snapshot: await this.snapshot(user.id), replayed: false };
   }
 
+  async assertAvailable() {
+    this.assertEnabled();
+    try {
+      await this.runtime.check();
+    } catch {
+      throw Object.assign(new Error('SANDBOX_DOCKER_UNAVAILABLE'), {
+        code: 'SANDBOX_DOCKER_UNAVAILABLE',
+      });
+    }
+  }
+
+  // User-visible lifecycle operations are admitted on every request. The
+  // feature flag and Docker reachability can change while a browser is open.
   async action(userId, action) {
+    return this.withOwnerLifecycle(userId, async () => {
+      await this.assertAvailable();
+      if (!this.ownerDb.isActive(userId)) {
+        throw Object.assign(new Error('SANDBOX_OWNER_INACTIVE'), { code: 'SANDBOX_OWNER_INACTIVE' });
+      }
+      const name = this.nameForUser(userId);
+      if (action === 'start') await this.runtime.start(name);
+      else if (action === 'retry') {
+        const current = await this.runtime.inspect(name);
+        if (current.exists) await this.runtime.start(name);
+        else throw Object.assign(new Error('SANDBOX_NOT_FOUND'), { code: 'SANDBOX_NOT_FOUND' });
+      }
+      else if (action === 'stop') await this.runtime.stop(name);
+      else if (action === 'remove') {
+        await this.runtime.remove(name);
+        await rm(join(this.config.stateDir, name), { recursive: true, force: true });
+      }
+      else throw Object.assign(new Error('SANDBOX_ACTION_NOT_ALLOWED'), { code: 'SANDBOX_ACTION_NOT_ALLOWED' });
+      return { snapshot: await this.snapshot(userId), replayed: false };
+    });
+  }
+
+  // Account deletion bypasses public admission only for durable Server-owned
+  // resources. No marker means this owner never reached a managed create
+  // attempt, so a default deployment without Docker must not probe the daemon.
+  async cleanupManagedContainer(userId) {
+    return this.withOwnerLifecycle(userId, () => this.cleanupManagedContainerLocked(userId));
+  }
+
+  async cleanupManagedContainerLocked(userId) {
     const name = this.nameForUser(userId);
-    if (action === 'start') await startContainerAgent(name);
-    else if (action === 'retry') {
-      const current = await inspectContainerAgent(name);
-      if (current.exists) await startContainerAgent(name);
-      else throw Object.assign(new Error('SANDBOX_NOT_FOUND'), { code: 'SANDBOX_NOT_FOUND' });
+    const ownerDir = join(this.config.stateDir, name);
+    const marker = join(ownerDir, 'agent-secret');
+    try {
+      await access(marker);
+    } catch (error) {
+      if (error?.code === 'ENOENT') return { cleaned: false };
+      throw error;
     }
-    else if (action === 'stop') await stopContainerAgent(name);
-    else if (action === 'remove') await removeContainerAgent(name);
-    else throw Object.assign(new Error('SANDBOX_ACTION_NOT_ALLOWED'), { code: 'SANDBOX_ACTION_NOT_ALLOWED' });
-    return { snapshot: await this.snapshot(userId), replayed: false };
+    await this.runtime.remove(name);
+    await rm(ownerDir, { recursive: true, force: true });
+    return { cleaned: true };
+  }
+
+  async prepareOwnerDeletion(userId, beginDeletion) {
+    if (typeof beginDeletion !== 'function') {
+      throw new TypeError('beginDeletion must be a function');
+    }
+    return this.withOwnerLifecycle(userId, async () => {
+      await this.cleanupManagedContainerLocked(userId);
+      return beginDeletion();
+    });
   }
 }
 

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

@@ -1,9 +1,9 @@
 import { userDb } from '../database.js';
 import { containerAgentService } from '../container-agent-service.js';
 
-function loadUser(req) {
-  let user = userDb.getByUsername(req.user.username);
-  if (!user && req.user.username === 'dev-user') user = userDb.getOrCreate('dev-user', 'dev-user');
+function loadUser(req, sandboxUserDb = userDb) {
+  let user = sandboxUserDb.getByUsername(req.user.username);
+  if (!user && req.user.username === 'dev-user') user = sandboxUserDb.getOrCreate('dev-user', 'dev-user');
   return user;
 }
 
@@ -14,29 +14,42 @@ function sendError(res, error) {
   return res.status(known ? 409 : 500).json({ code: known ? code : 'SANDBOX_INTERNAL_ERROR' });
 }
 
-export function registerSandboxRoutes(app, { requireAuth }) {
-  app.get('/api/sandbox/capability', requireAuth, (_req, res) => {
-    res.json(containerAgentService.capability());
+/**
+ * Register user-owned Sandbox lifecycle routes.
+ *
+ * @param {object} app Express-compatible route registrar
+ * @param {{ requireAuth: Function, sandboxService?: object, sandboxUserDb?: object }} dependencies
+ */
+export function registerSandboxRoutes(app, {
+  requireAuth,
+  sandboxService = containerAgentService,
+  sandboxUserDb = userDb,
+}) {
+  app.get('/api/sandbox/capability', requireAuth, async (_req, res) => {
+    res.json(await sandboxService.capability());
   });
 
   app.get('/api/sandbox', requireAuth, async (req, res) => {
-    const user = loadUser(req);
+    const user = loadUser(req, sandboxUserDb);
     if (!user) return res.status(404).json({ code: 'USER_NOT_FOUND' });
     try {
-      return res.json({ sandbox: await containerAgentService.snapshot(user.id) });
+      // Older browsers request capability and snapshot concurrently. Keep their
+      // snapshot response successful when the Docker runtime is unavailable so
+      // the capability reason remains visible instead of a generic load error.
+      const capability = await sandboxService.capability();
+      if (!capability.available) return res.json({ sandbox: null });
+      return res.json({ sandbox: await sandboxService.snapshot(user.id) });
     } catch (error) {
       return sendError(res, error);
     }
   });
 
   app.post('/api/sandbox', requireAuth, async (req, res) => {
-    const user = loadUser(req);
+    const user = loadUser(req, sandboxUserDb);
     if (!user) return res.status(404).json({ code: 'USER_NOT_FOUND' });
     try {
-      const agentSecret = userDb.getAgentSecret(user.id) || userDb.resetAgentSecret(user.id);
-      const result = await containerAgentService.create({ ...user, agent_secret: agentSecret }, {
-        agentName: req.body?.agentName,
-      });
+      const agentSecret = sandboxUserDb.getAgentSecret(user.id) || sandboxUserDb.resetAgentSecret(user.id);
+      const result = await sandboxService.create({ ...user, agent_secret: agentSecret });
       return res.status(201).json(result);
     } catch (error) {
       return sendError(res, error);
@@ -45,10 +58,10 @@ export function registerSandboxRoutes(app, { requireAuth }) {
 
   for (const action of ['start', 'stop', 'retry', 'remove']) {
     app.post(`/api/sandbox/${action}`, requireAuth, async (req, res) => {
-      const user = loadUser(req);
+      const user = loadUser(req, sandboxUserDb);
       if (!user) return res.status(404).json({ code: 'USER_NOT_FOUND' });
       try {
-        return res.json(await containerAgentService.action(user.id, action));
+        return res.json(await sandboxService.action(user.id, action));
       } catch (error) {
         return sendError(res, error);
       }

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

@@ -54,7 +54,11 @@ function ensureAgentSecret(user) {
 /**
  * Register user profile, agent secret, and admin user management routes.
  */
-export function registerUserRoutes(app, { requireAuth, requireAdmin }) {
+export function registerUserRoutes(app, {
+  requireAuth,
+  requireAdmin,
+  containerService = containerAgentService,
+}) {
   // Get my profile
   app.get('/api/user/profile', requireAuth, (req, res) => {
     try {
@@ -155,10 +159,12 @@ 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);
+      // Keep managed cleanup and the durable active -> pending transition inside
+      // one owner lifecycle fence so an admitted create cannot outlive deletion.
+      const deletion = await containerService.prepareOwnerDeletion(
+        user.id,
+        () => userDb.beginDeletion(user.id),
+      );
       if (!deletion) return res.status(404).json({ error: 'User not found or already deleted' });
 
       // Durable eligibility is enforced from the user row. These sweeps close

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.406"}
+{"version":"1.0.408"}