@yeaft/webchat-agent 1.0.415 → 1.0.416

package/local-runtime/agent/container-manager.js

@@ -0,0 +1,189 @@
+import { spawn } from 'node:child_process';
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+
+export const DEFAULT_AGENT_IMAGE = 'ghcr.io/yeaft/yeaft-web-code-agent-agent:dev';
+const NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,63}$/;
+
+export class ContainerAgentError extends Error {
+  constructor(code, message = code) {
+    super(message);
+    this.name = 'ContainerAgentError';
+    this.code = code;
+  }
+}
+
+export function normalizeContainerAgentName(name) {
+  const value = String(name || '').trim();
+  if (!NAME_PATTERN.test(value)) throw new ContainerAgentError('CONTAINER_AGENT_INVALID_NAME');
+  return value;
+}
+
+export function containerNameForAgent(name) {
+  return `yeaft-agent-${normalizeContainerAgentName(name)}`;
+}
+
+export async function runDocker(args, { spawnImpl = spawn, allowFailure = false, stdout = 'pipe' } = {}) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawnImpl('docker', args, {
+      stdio: ['ignore', stdout, 'pipe'],
+      windowsHide: true,
+    });
+    const output = [];
+    const errors = [];
+    child.stdout?.on('data', chunk => output.push(chunk));
+    child.stderr?.on('data', chunk => errors.push(chunk));
+    child.once('error', error => reject(new ContainerAgentError('CONTAINER_AGENT_DOCKER_UNAVAILABLE', error.message)));
+    child.once('close', code => {
+      const result = {
+        code: code ?? 1,
+        stdout: Buffer.concat(output).toString('utf8').trim(),
+        stderr: Buffer.concat(errors).toString('utf8').trim(),
+      };
+      if (result.code === 0 || allowFailure) resolvePromise(result);
+      else reject(new ContainerAgentError('CONTAINER_AGENT_DOCKER_FAILED', result.stderr || `docker ${args[0]} failed`));
+    });
+  });
+}
+
+export async function writeAgentSecretFile(path, secret) {
+  const value = String(secret || '').trim();
+  if (!value) throw new ContainerAgentError('CONTAINER_AGENT_SECRET_REQUIRED');
+  const absolute = resolve(path);
+  await mkdir(dirname(absolute), { recursive: true, mode: 0o700 });
+  await writeFile(absolute, `${value}\n`, { mode: 0o600 });
+  await chmod(absolute, 0o600);
+  return absolute;
+}
+
+export function buildCreateArgs({
+  name,
+  serverUrl,
+  secretFile,
+  image = DEFAULT_AGENT_IMAGE,
+  dataVolume,
+  workspaceVolume,
+  restart = 'unless-stopped',
+}) {
+  const agentName = normalizeContainerAgentName(name);
+  if (!String(serverUrl || '').match(/^wss?:\/\//)) {
+    throw new ContainerAgentError('CONTAINER_AGENT_INVALID_SERVER_URL');
+  }
+  if (!secretFile) throw new ContainerAgentError('CONTAINER_AGENT_SECRET_REQUIRED');
+  const containerName = containerNameForAgent(agentName);
+  const safeImage = String(image || '').trim();
+  if (!safeImage || safeImage.startsWith('-')) throw new ContainerAgentError('CONTAINER_AGENT_INVALID_IMAGE');
+  return [
+    'create', '--name', containerName,
+    '--label', 'io.yeaft.container-agent=true',
+    '--label', `io.yeaft.agent-name=${agentName}`,
+    '--restart', restart,
+    '--init',
+    '--mount', `type=volume,src=${dataVolume || `${containerName}-data`},dst=/home/yeaft/.yeaft`,
+    '--mount', `type=volume,src=${workspaceVolume || `${containerName}-workspace`},dst=/workspace`,
+    '--mount', `type=bind,src=${resolve(secretFile)},dst=/run/yeaft-host-secret,readonly`,
+    '--env', `SERVER_URL=${serverUrl}`,
+    '--env', `AGENT_NAME=${agentName}`,
+    '--env', 'AGENT_SECRET_FILE=/run/yeaft-host-secret',
+    '--env', 'YEAFT_DIR=/home/yeaft/.yeaft',
+    '--env', 'WORK_DIR=/workspace',
+    safeImage,
+  ];
+}
+
+/**
+ * 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),
+  ], { ...options, allowFailure: true });
+  if (result.code !== 0) {
+    if (/no such (object|container)/i.test(result.stderr)) {
+      return { exists: false, status: 'absent', running: false };
+    }
+    throw new ContainerAgentError('CONTAINER_AGENT_DOCKER_FAILED', result.stderr || 'docker inspect failed');
+  }
+  try {
+    const state = JSON.parse(result.stdout);
+    return {
+      exists: true,
+      status: state.Status || 'unknown',
+      running: state.Running === true,
+      startedAt: state.StartedAt || null,
+      error: state.Error || null,
+    };
+  } catch {
+    throw new ContainerAgentError('CONTAINER_AGENT_INVALID_DOCKER_RESPONSE');
+  }
+}
+
+export async function createContainerAgent(options, runtime = {}) {
+  const current = await inspectContainerAgent(options.name, runtime);
+  if (current.exists) throw new ContainerAgentError('CONTAINER_AGENT_ALREADY_EXISTS');
+  const containerName = containerNameForAgent(options.name);
+  await runDocker(buildCreateArgs(options), runtime);
+  try {
+    await runDocker(['start', containerName], runtime);
+  } catch (error) {
+    await runDocker(['rm', '-f', containerName], { ...runtime, allowFailure: true });
+    throw error;
+  }
+  return inspectContainerAgent(options.name, runtime);
+}
+
+export async function startContainerAgent(name, runtime = {}) {
+  await runDocker(['start', containerNameForAgent(name)], runtime);
+  return inspectContainerAgent(name, runtime);
+}
+
+export async function stopContainerAgent(name, runtime = {}) {
+  await runDocker(['stop', '--time', '10', containerNameForAgent(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) {
+    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 };
+}
+
+export async function logsContainerAgent(name, { follow = false, ...runtime } = {}) {
+  const args = ['logs'];
+  if (follow) args.push('--follow');
+  args.push(containerNameForAgent(name));
+  return runDocker(args, { ...runtime, stdout: follow ? 'inherit' : 'pipe' });
+}
+
+export async function readSecretInput({ secret, secretFile }) {
+  if (secretFile) return (await readFile(resolve(secretFile), 'utf8')).trim();
+  return String(secret || '').trim();
+}

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.415"}
+{"version":"1.0.416"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.415",
+  "version": "1.0.416",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/scripts/prepare-local-runtime.js

@@ -1,25 +1,44 @@
 import { cpSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
-import { dirname, join } from 'path';
+import { dirname, join, resolve } from 'path';
 import { fileURLToPath } from 'url';
 
-const agentDir = join(dirname(fileURLToPath(import.meta.url)), '..');
-const rootDir = join(agentDir, '..');
-const runtimeDir = join(agentDir, 'local-runtime');
+const scriptPath = fileURLToPath(import.meta.url);
+const defaultAgentDir = join(dirname(scriptPath), '..');
 
-rmSync(runtimeDir, { recursive: true, force: true });
-mkdirSync(runtimeDir, { recursive: true });
-const excludedServerPaths = new Set([
-  join(rootDir, 'server', 'node_modules'),
-  join(rootDir, 'server', 'data'),
-  join(rootDir, 'server', '.env'),
-  join(rootDir, 'server', 'user.json'),
-  join(rootDir, 'server', 'users.json'),
-]);
-cpSync(join(rootDir, 'server'), join(runtimeDir, 'server'), {
-  recursive: true,
-  filter: source => !excludedServerPaths.has(source),
-});
-cpSync(join(rootDir, 'web', 'dist'), join(runtimeDir, 'web'), { recursive: true });
+/**
+ * Build the Server and Web payload embedded in the published Agent package.
+ * Server imports that cross into agent/ must be copied explicitly so the
+ * packaged local runtime has the same module boundary as the source tree.
+ */
+export function prepareLocalRuntime({
+  agentDir = defaultAgentDir,
+  rootDir = join(agentDir, '..'),
+  runtimeDir = join(agentDir, 'local-runtime'),
+} = {}) {
+  rmSync(runtimeDir, { recursive: true, force: true });
+  mkdirSync(runtimeDir, { recursive: true });
+  const excludedServerPaths = new Set([
+    join(rootDir, 'server', 'node_modules'),
+    join(rootDir, 'server', 'data'),
+    join(rootDir, 'server', '.env'),
+    join(rootDir, 'server', 'user.json'),
+    join(rootDir, 'server', 'users.json'),
+  ]);
+  cpSync(join(rootDir, 'server'), join(runtimeDir, 'server'), {
+    recursive: true,
+    filter: source => !excludedServerPaths.has(source),
+  });
+  cpSync(join(rootDir, 'web', 'dist'), join(runtimeDir, 'web'), { recursive: true });
 
-const { version } = JSON.parse(readFileSync(join(agentDir, 'package.json'), 'utf8'));
-writeFileSync(join(runtimeDir, 'version.json'), `${JSON.stringify({ version })}\n`);
+  const runtimeAgentDir = join(runtimeDir, 'agent');
+  mkdirSync(runtimeAgentDir, { recursive: true });
+  cpSync(join(agentDir, 'container-manager.js'), join(runtimeAgentDir, 'container-manager.js'));
+
+  const { version } = JSON.parse(readFileSync(join(agentDir, 'package.json'), 'utf8'));
+  writeFileSync(join(runtimeDir, 'version.json'), `${JSON.stringify({ version })}\n`);
+  return runtimeDir;
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === resolve(scriptPath)) {
+  prepareLocalRuntime();
+}