@flame0510/project-aether 1.1.9

package/app/api/agents/route.ts

@@ -0,0 +1,213 @@
+import { NextResponse, type NextRequest } from 'next/server';
+import * as http from 'http';
+import * as fs from 'fs';
+import * as path from 'path';
+import { detectPublicHost } from '@/lib/docker-utils';
+import { AGENTS_TOKEN_FILE } from '@/lib/rev4a-paths';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+const DOCKER_SOCKET = '/var/run/docker.sock';
+
+function dockerFetch(method: string, path: string): Promise<any> {
+  return new Promise((resolve, reject) => {
+    const options = {
+      socketPath: DOCKER_SOCKET,
+      path,
+      method,
+      headers: { 'Host': 'localhost' } as any,
+    };
+    const req = http.request(options, (res: any) => {
+      let data = '';
+      res.on('data', (chunk: string) => (data += chunk));
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch {
+          reject(new Error('Invalid JSON from Docker API'));
+        }
+      });
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+export const dynamic = 'force-dynamic';
+
+function dockerAvailable(): boolean {
+  try {
+    fs.accessSync(DOCKER_SOCKET, fs.constants.R_OK | fs.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  // If Docker is not available (e.g. testing environment), return empty list
+  if (!dockerAvailable()) {
+    return NextResponse.json([]);
+  }
+
+  try {
+    // List all containers (including stopped) with AGENT_ID label via Docker API
+    const containers: any[] = await dockerFetch(
+      'GET',
+      '/containers/json?all=true&filters={"label":["AGENT_ID"]}',
+    );
+
+    // Current image ID — used to detect outdated containers
+    let currentImageId = '';
+    try {
+      const imageInspect = await dockerFetch('GET', '/images/openclaw-agent-base:latest/json');
+      currentImageId = imageInspect.Id || '';
+    } catch {
+      // Image doesn't exist yet — all containers are fine
+    }
+
+    const agents = await Promise.all(
+      containers.map(async (c: any) => {
+        const agentId = c.Labels?.AGENT_ID || 'unknown';
+        let ip: string | null = null;
+        let created: string | null = null;
+        let env: string[] = [];
+        let authToken: string | null = null;
+        let traefikUrl: string | null = null;
+        let portBindings: Record<string, Array<{ HostIp: string; HostPort: string }>> | null = null;
+
+        try {
+          const inspect: any = await dockerFetch(
+            'GET',
+            `/containers/${c.Id}/json`,
+          );
+          const networks: Record<string, any> =
+            inspect.NetworkSettings?.Networks || {};
+          ip =
+            Object.values(networks).find(
+              (n: any) => n.IPAddress,
+            )?.IPAddress || null;
+          created = inspect.Created || null;
+          env = (inspect.Config?.Env || []).filter((e: string) =>
+            e.startsWith('AGENT_') || e.startsWith('MODEL_')
+          );
+
+          // Ports from inspect (HostConfig) — works even when container is stopped
+          portBindings = inspect.HostConfig?.PortBindings || null;
+
+          // Read auth token — always prefer the shared agents-token.json (user-managed)
+          const cName = (c.Names?.[0] || '').replace(/^\//, '');
+          try {
+            const tokenRaw = fs.readFileSync(
+              AGENTS_TOKEN_FILE,
+              'utf-8'
+            );
+            const tokenData = JSON.parse(tokenRaw);
+            if (tokenData.token) {
+              authToken = tokenData.token;
+            }
+          } catch {
+            // agents-token.json unavailable
+          }
+
+          // Fallback only if shared token is missing: try the container's own gateway token
+          if (!authToken) {
+            try {
+              const { execSync } = require('child_process');
+              let token = execSync(
+                `docker exec ${cName} sh -c 'grep ^OPENCLAW_GATEWAY_TOKEN= /root/….env 2>/dev/null | cut -d= -f2- | tr -d "\"\""' 2>/dev/null || echo ''`,
+                { timeout: 5000, encoding: 'utf-8' }
+              ).toString().trim();
+              if (token && token !== 'undefined') authToken = token;
+            } catch {
+              // token unavailable for this container
+            }
+          }
+
+          // Build the agent URL from the host's public IP + mapped port.
+          // Every agent has -p <port>:3000, so we look for the public port
+          // that maps to the internal port 3000.
+          // Use portBindings from inspect (works stopped) with fallback to c.Ports (running only).
+          const port3000Binding = portBindings?.['3000/tcp'];
+          const publicPort = port3000Binding?.[0]?.HostPort
+            || (c.Ports || []).find((p: any) => p.PublicPort && p.PrivatePort === 3000)?.PublicPort
+            || null;
+          if (publicPort) {
+            const host = detectPublicHost();
+            let baseUrl = `http://${host}:${publicPort}`;
+            if (authToken) {
+              baseUrl += `#token=${encodeURIComponent(authToken)}`;
+            }
+            traefikUrl = baseUrl;
+          }
+        } catch {
+          // inspect non-critical, continue with partial data
+        }
+
+        // Determine template from AGENT_TEMPLATE env var.
+        // Falls back to 'custom' if not set (agent created before this feature).
+        const image: string = c.Image || '';
+        let template: string | null = null;
+        if (image.startsWith('openclaw-agent-base')) {
+          const templateLine = env.find((e: string) => e.startsWith('AGENT_TEMPLATE='));
+          template = templateLine ? templateLine.split('=').slice(1).join('=') : 'custom';
+        }
+
+        // Build ports string from portBindings (works stopped) with fallback to c.Ports (running only)
+        let ports = '';
+        if (portBindings && Object.keys(portBindings).length > 0) {
+          ports = Object.entries(portBindings)
+            .flatMap(([containerPort, hostPorts]) =>
+              (hostPorts as any[]).map((h: any) => `${h.HostPort}:${containerPort.replace('/tcp', '')}${containerPort.includes('/udp') ? '/udp' : ''}`)
+            )
+            .join(', ');
+        } else {
+          ports = (c.Ports || [])
+            .filter((p: any) => p.PublicPort)
+            .map(
+              (p: any) =>
+                `${p.PublicPort}:${p.PrivatePort}${p.Type === 'udp' ? '/udp' : ''}`,
+            )
+            .join(', ');
+        }
+
+        return {
+          id: (c.Id || '').slice(0, 12),
+          agentId,
+          name: (c.Names?.[0] || '').replace(/^\//, ''),
+          displayName: (env.find((e: string) => e.startsWith('AGENT_NAME=')) || '').split('=').slice(1).join('=') || (c.Names?.[0] || '').replace(/^\//, ''),
+          image,
+          imageTag: image.includes(':') ? image.split(':')[1] || 'latest' : (image.includes('@') ? 'digest' : 'latest'),
+          template,
+          status: c.Status || 'unknown',
+          state: c.State || 'unknown',
+          ports,
+          ip,
+          created,
+          env,
+          traefikUrl,
+          authToken,
+          // Flag as outdated when the container's image differs from the current base image.
+          // We compare raw ImageID digests — no fragile name-based filtering.
+          imageOutdated: currentImageId ? c.ImageID !== currentImageId : false,
+        };
+      }),
+    );
+
+    // Deduplicate by agentId > use the running one when multiple
+    const seen = new Map<string, typeof agents[0]>();
+    for (const agent of agents) {
+      const existing = seen.get(agent.agentId);
+      if (!existing || (agent.state === 'running' && existing.state !== 'running')) {
+        seen.set(agent.agentId, agent);
+      }
+    }
+
+    return NextResponse.json(Array.from(seen.values()));
+  } catch (e: unknown) {
+    return NextResponse.json(
+      { error: (e as Error).message },
+      { status: 500 },
+    );
+  }
+}

package/app/api/agents/token/route.ts

@@ -0,0 +1,94 @@
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import { NextResponse, type NextRequest } from 'next/server';
+import { AGENTS_TOKEN_FILE } from '@/lib/rev4a-paths';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+
+interface TokenData {
+  token: string;
+  updated_at: number;
+}
+
+function readTokenFile(): TokenData {
+  try {
+    const raw = fs.readFileSync(AGENTS_TOKEN_FILE, 'utf-8');
+    const data = JSON.parse(raw);
+    return {
+      token: typeof data.token === 'string' ? data.token : '',
+      updated_at: typeof data.updated_at === 'number' ? data.updated_at : 0,
+    };
+  } catch {
+    return { token: '', updated_at: 0 };
+  }
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  return NextResponse.json(readTokenFile());
+}
+
+export async function PUT(request: NextRequest): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  try {
+    const body = await request.json();
+    const token = typeof body?.token === 'string' ? body.token : null;
+
+    if (token === null) {
+      return NextResponse.json(
+        { success: false, error: 'Invalid token payload' },
+        { status: 400 },
+      );
+    }
+
+    const payload: TokenData = {
+      token,
+      updated_at: Date.now(),
+    };
+
+    fs.mkdirSync(require('path').dirname(AGENTS_TOKEN_FILE), { recursive: true });
+    fs.writeFileSync(AGENTS_TOKEN_FILE, JSON.stringify(payload, null, 2));
+
+    let containersUpdated = 0;
+    let containerNames: string[] = [];
+
+    try {
+      const raw = execSync(
+        `docker ps --filter "label=AGENT_ID" --format "{{.Names}}"`,
+        { encoding: 'utf-8', timeout: 5000 },
+      ).trim();
+      containerNames = raw ? raw.split('\n').map((name) => name.trim()).filter(Boolean) : [];
+    } catch {
+      containerNames = [];
+    }
+
+    for (const containerName of containerNames) {
+      try {
+        // Write token to /root/.agent-token (entrypoint reads this, overrides env var)
+        execSync(
+          `docker exec ${shellQuote(containerName)} sh -c 'echo ${shellQuote(token)} > /root/.agent-token'`,
+          { encoding: 'utf-8', timeout: 10000 },
+        );
+        // Restart to pick up new token
+        execSync(`docker restart ${shellQuote(containerName)}`, {
+          encoding: 'utf-8',
+          timeout: 20000,
+        });
+        containersUpdated += 1;
+      } catch {
+        // Skip failed containers and continue syncing the rest.
+      }
+    }
+
+    return NextResponse.json({ success: true, containersUpdated });
+  } catch (e: unknown) {
+    return NextResponse.json(
+      { success: false, error: (e as Error).message || 'Unknown error' },
+      { status: 500 },
+    );
+  }
+}

package/app/api/agents-active/route.ts

@@ -0,0 +1,190 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { NextResponse, type NextRequest } from 'next/server';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+
+interface WorkspaceFile {
+  name: string;
+  path: string;
+  rel_path: string;
+  type: 'markdown' | 'json' | 'html' | 'pdf' | 'script' | 'typescript' | 'stylesheet' | 'yaml' | 'env' | 'text' | 'folder';
+}
+
+interface ConfiguredAgent {
+  id: string;
+  label?: string;
+  model?: string;
+  defaultModel?: string;
+  default_model?: string;
+  [key: string]: unknown;
+}
+
+const ALLOWED_EXT = new Set(['.md', '.json', '.txt', '.html', '.py', '.css', '.js', '.ts', '.tsx', '.yaml', '.yml', '.env', '.sh', '.pdf']);
+
+function fileTypeFromExt(ext: string): WorkspaceFile['type'] {
+  if (ext === '.md') return 'markdown';
+  if (ext === '.json') return 'json';
+  if (ext === '.html') return 'html';
+  if (ext === '.pdf') return 'pdf';
+  if (ext === '.py' || ext === '.sh') return 'script';
+  if (ext === '.js' || ext === '.ts' || ext === '.tsx') return 'typescript';
+  if (ext === '.css') return 'stylesheet';
+  if (ext === '.yaml' || ext === '.yml') return 'yaml';
+  if (ext === '.env') return 'env';
+  return 'text';
+}
+
+const MAX_WORKSPACE_TREE_DEPTH = 32;
+const MAX_WORKSPACE_TREE_ITEMS = 5000;
+
+function listWorkspaceFiles(workspacePath: string): WorkspaceFile[] {
+  const out: WorkspaceFile[] = [];
+
+  function walk(dir: string, depth: number, prefix = '') {
+    if (depth > MAX_WORKSPACE_TREE_DEPTH) return;
+    let entries: fs.Dirent[] = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true })
+        .sort((a, b) => {
+          if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
+          return a.name.localeCompare(b.name);
+        });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith('.')) continue;
+      const absPath = path.join(dir, entry.name);
+      const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        if (entry.name === 'node_modules' || entry.name === '.trash') continue;
+        out.push({ name: entry.name, path: absPath, rel_path: relPath, type: 'folder' });
+        walk(absPath, depth + 1, relPath);
+        continue;
+      }
+      const ext = path.extname(entry.name).toLowerCase();
+      if (!ALLOWED_EXT.has(ext)) continue;
+      out.push({ name: entry.name, path: absPath, rel_path: relPath, type: fileTypeFromExt(ext) });
+    }
+  }
+
+  walk(workspacePath, 0);
+  const rootFiles = out.filter((f) => f.type !== 'folder' && !f.rel_path.includes('/'));
+  const rootFolders = out.filter((f) => f.type === 'folder' && !f.rel_path.includes('/'));
+  const rest = out.filter((f) => f.rel_path.includes('/'));
+
+  rootFiles.sort((a, b) => a.rel_path.localeCompare(b.rel_path));
+  rootFolders.sort((a, b) => a.rel_path.localeCompare(b.rel_path));
+  rest.sort((a, b) => a.rel_path.localeCompare(b.rel_path));
+
+  return [...rootFiles, ...rootFolders, ...rest].slice(0, MAX_WORKSPACE_TREE_ITEMS);
+}
+
+function readConfiguredAgents(): ConfiguredAgent[] {
+  try {
+    const raw = fs.readFileSync('/data/.openclaw/openclaw.json', 'utf8');
+    const parsed = JSON.parse(raw) as { agents?: { list?: unknown[] } };
+    const list = parsed?.agents?.list;
+    if (!Array.isArray(list)) return [];
+    return list.filter(
+      (a): a is ConfiguredAgent => !!a && typeof (a as ConfiguredAgent).id === 'string',
+    );
+  } catch {
+    return [];
+  }
+}
+
+function readDockerAgents(): { id: string; agentId: string; name: string; image: string; status: string; ports: string }[] {
+  try {
+    const output = execSync(
+      'docker ps --filter "label=AGENT_ID" --format "{{.ID}}|{{.Label \"AGENT_ID\"}}|{{.Names}}|{{.Image}}|{{.Status}}|{{.Ports}}"',
+      { timeout: 5000, encoding: 'utf-8' },
+    ).trim();
+    if (!output) return [];
+    return output.split('\n').map((line) => {
+      const [id, agentId, name, image, status, ports] = line.split('|');
+      return { id, agentId, name, image, status, ports };
+    });
+  } catch {
+    return [];
+  }
+}
+
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  try {
+    const configuredAgents = readConfiguredAgents();
+    const dockerAgents = readDockerAgents();
+    const dockerAgentIds = new Set(dockerAgents.map((d) => d.agentId));
+
+    // Map workspace paths per agent
+    const agents = configuredAgents.map((cfg) => {
+      const agent_id = cfg.id;
+      const dockerInfo = dockerAgents.find((d) => d.agentId === agent_id);
+      const workspace_path = agent_id === 'ops' || agent_id === 'core'
+        ? '/data/.openclaw/workspace-ops/'
+        : `/data/.openclaw/workspace-${agent_id}/`;
+
+      // Only read workspace for agents on the host (not running as separate containers)
+      const files = dockerInfo ? [] : (fs.existsSync(workspace_path) ? listWorkspaceFiles(workspace_path) : []);
+
+      const config_model = formatModel(cfg.model ?? cfg.defaultModel ?? cfg.default_model);
+      const status = dockerInfo
+        ? (dockerInfo.status.startsWith('Up') ? 'running' : dockerInfo.status.toLowerCase())
+        : 'inactive';
+
+      return {
+        agent_id,
+        label: cfg.label ?? agent_id,
+        config_model,
+        workspace_path,
+        files,
+        docker: dockerInfo ?? null,
+        status,
+        config: cfg,
+      };
+    });
+
+    // Add any Docker-only agents not in config
+    for (const d of dockerAgents) {
+      if (!configuredAgents.find((c) => c.id === d.agentId)) {
+        // Read AGENT_NAME env for display name
+        let label = d.agentId;
+        try {
+          const displayName = execSync(
+            `docker exec ${d.name} sh -c 'printenv AGENT_NAME'`,
+            { timeout: 3000, encoding: 'utf-8' },
+          ).trim();
+          if (displayName) label = displayName;
+        } catch { /* use fallback */ }
+        agents.push({
+          agent_id: d.agentId,
+          label,
+          config_model: null,
+          workspace_path: '',
+          files: [],
+          docker: d as any,
+          status: d.status.startsWith('Up') ? 'running' : d.status.toLowerCase(),
+          config: {} as ConfiguredAgent,
+        });
+      }
+    }
+
+    return NextResponse.json(agents);
+  } catch (e: unknown) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}
+
+function formatModel(value: unknown): string | null {
+  if (typeof value === 'string') return value;
+  if (value && typeof value === 'object') {
+    const model = value as { primary?: unknown; model?: unknown; provider?: unknown };
+    if (typeof model.primary === 'string') return model.primary;
+    if (typeof model.model === 'string') return model.provider ? `${String(model.provider)}/${model.model}` : model.model;
+  }
+  return null;
+}