@flame0510/project-aether 1.1.9

package/app/api/skills/route.js

@@ -0,0 +1,203 @@
+import { NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import { execSync, execFileSync } from 'child_process';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+const SHARED_SKILLS_DIR = '/docker/shared-skills';
+const CONTAINER_BUNDLED_SKILLS_DIR = '/usr/local/lib/node_modules/openclaw/skills';
+
+function readSkillMeta(skillDir, name, type, agentId) {
+  const skillMdPath = path.join(skillDir, name, 'SKILL.md');
+  let description = '';
+  let version = '';
+  let hasSkillMd = false;
+
+  try {
+    const content = fs.readFileSync(skillMdPath, 'utf8');
+    hasSkillMd = true;
+    const descMatch = content.match(/^description:\s*(.+)$/m);
+    const verMatch = content.match(/^\*\*Version:\*\*\s*(.+)$/m) || content.match(/^version:\s*(.+)$/m);
+    if (descMatch) description = descMatch[1].trim();
+    if (verMatch) version = verMatch[1].trim();
+  } catch {}
+
+  const result = {
+    name,
+    type,
+    path: path.join(skillDir, name),
+    skillMdPath: hasSkillMd ? skillMdPath : null,
+    hasSkillMd,
+    description,
+    version,
+  };
+
+  if (agentId) result.agentId = agentId;
+
+  return result;
+}
+
+/**
+ * Discover agent containers with AGENT_ID label.
+ * Returns [{ containerName, agentId }]
+ */
+function discoverAgentContainers() {
+  try {
+    // Get container names with AGENT_ID label
+    const namesRaw = execFileSync('docker', [
+      'ps', '--filter', 'label=AGENT_ID', '--format', '{{.Names}}'
+    ], { encoding: 'utf8', timeout: 5000 }).trim();
+    if (!namesRaw) return [];
+
+    return namesRaw.split('\n').map(name => {
+      const containerName = name.trim();
+      if (!containerName) return null;
+      // Get agent ID from label using docker inspect
+      const agentId = execFileSync('docker', [
+        'inspect', containerName, '--format', '{{index .Config.Labels "AGENT_ID"}}'
+      ], { encoding: 'utf8', timeout: 5000 }).trim();
+      return { containerName, agentId: agentId || containerName };
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Read skill directories from a container agent's workspace via docker exec.
+ * Returns an array of skill names found.
+ */
+function readContainerSkillDirs(containerName) {
+  const workspaceSkillsPath = '/root/.openclaw/workspace/skills';
+  try {
+    // Check if the skills directory exists
+    execFileSync('docker', ['exec', containerName, 'test', '-d', workspaceSkillsPath], {
+      encoding: 'utf8', timeout: 5000
+    });
+
+    // List subdirectories (each is a potential skill)
+    const raw = execFileSync('docker', ['exec', containerName, 'ls', '-1', workspaceSkillsPath], {
+      encoding: 'utf8', timeout: 5000
+    }).trim();
+
+    if (!raw) return [];
+
+    return raw.split('\n').map(line => line.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Read SKILL.md content from inside a container.
+ */
+function readContainerSkillMd(containerName, skillName) {
+  const filePath = `/root/.openclaw/workspace/skills/${skillName}/SKILL.md`;
+  try {
+    return execFileSync('docker', ['exec', containerName, 'cat', filePath], {
+      encoding: 'utf8', timeout: 5000
+    });
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse description and version from SKILL.md content string.
+ */
+function parseSkillContent(content) {
+  let description = '';
+  let version = '';
+  if (!content) return { description, version };
+
+  const descMatch = content.match(/^description:\s*(.+)$/m);
+  const verMatch = content.match(/^\*\*Version:\*\*\s*(.+)$/m) || content.match(/^version:\s*(.+)$/m);
+  if (descMatch) description = descMatch[1].trim();
+  if (verMatch) version = verMatch[1].trim();
+
+  return { description, version };
+}
+
+export async function GET(request) {
+  const denied = await requireAuthJWT(request); if (denied) return denied;
+  const skills = [];
+
+  // 1. Shared skills
+  try {
+    if (fs.existsSync(SHARED_SKILLS_DIR)) {
+      const entries = fs.readdirSync(SHARED_SKILLS_DIR, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const skillMd = path.join(SHARED_SKILLS_DIR, entry.name, 'SKILL.md');
+        if (fs.existsSync(skillMd)) {
+          skills.push(readSkillMeta(SHARED_SKILLS_DIR, entry.name, 'shared', null));
+        }
+      }
+    }
+  } catch {}
+
+  // 2. Agent container skills (workspace-local)
+  const agents = discoverAgentContainers();
+  for (const agent of agents) {
+    const dirs = readContainerSkillDirs(agent.containerName);
+    for (const dir of dirs) {
+      const content = readContainerSkillMd(agent.containerName, dir);
+      if (content) {
+        const { description, version } = parseSkillContent(content);
+        skills.push({
+          name: dir,
+          type: 'workspace',
+          agentId: agent.agentId,
+          containerName: agent.containerName,
+          path: `/root/.openclaw/workspace/skills/${dir}`,
+          skillMdPath: `/root/.openclaw/workspace/skills/${dir}/SKILL.md`,
+          hasSkillMd: true,
+          description,
+          version,
+        });
+      }
+    }
+  }
+
+  // 3. Bundled skills (read-only) — discover from any agent container
+  try {
+    let bundledDirNames = [];
+    let bundledSourceContainer = null;
+
+    if (agents.length > 0) {
+      for (const agent of agents) {
+        try {
+          const raw = execFileSync('docker', [
+            'exec', agent.containerName, 'ls', '-1', CONTAINER_BUNDLED_SKILLS_DIR
+          ], { encoding: 'utf8', timeout: 5000 }).trim();
+          if (raw) {
+            bundledDirNames = raw.split('\n').map(l => l.trim()).filter(Boolean);
+            bundledSourceContainer = agent.containerName;
+            break;
+          }
+        } catch { /* try next container */ }
+      }
+    }
+
+    for (const name of bundledDirNames) {
+      try {
+        const skillMdPath = `${CONTAINER_BUNDLED_SKILLS_DIR}/${name}/SKILL.md`;
+        const content = execFileSync('docker', [
+          'exec', bundledSourceContainer, 'cat', skillMdPath
+        ], { encoding: 'utf8', timeout: 5000 });
+        const { description, version } = parseSkillContent(content);
+        skills.push({
+          name,
+          type: 'bundled',
+          path: `${CONTAINER_BUNDLED_SKILLS_DIR}/${name}`,
+          skillMdPath,
+          hasSkillMd: true,
+          description,
+          version,
+        });
+      } catch { /* skip this skill */ }
+    }
+  } catch {}
+
+  return NextResponse.json({ skills });
+}

package/app/api/skills/save/route.js

@@ -0,0 +1,142 @@
+import { NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import { execSync, execFileSync } from 'child_process';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+const SHARED_SKILLS_DIR = '/docker/shared-skills';
+const BUNDLED_SKILLS_DIR = '/usr/lib/node_modules/openclaw/skills';
+
+/**
+ * Read SKILL.md content from various sources:
+ * - Host path (shared / bundled)
+ * - Container path (via docker exec)
+ */
+function readSkillContent(skillPath, containerName) {
+  if (containerName) {
+    // Container skill — read via docker exec
+    try {
+      return execFileSync('docker', ['exec', containerName, 'cat', skillPath], {
+        encoding: 'utf8', timeout: 5000
+      });
+    } catch {
+      throw Object.assign(new Error(`Skill not found in container ${containerName}`), { status: 404 });
+    }
+  }
+
+  // Host skill
+  if (!fs.existsSync(skillPath)) {
+    throw Object.assign(new Error('Skill not found'), { status: 404 });
+  }
+
+  return fs.readFileSync(skillPath, 'utf8');
+}
+
+/**
+ * Write SKILL.md content.
+ * Shared skills — write to host filesystem.
+ * Container workspace skills — write via docker exec.
+ */
+function writeSkillContent(skillPath, containerName, content) {
+  if (containerName) {
+    // Container skill — write via docker exec heredoc
+    const escapedContent = content
+      .replace(/\\/g, '\\\\')
+      .replace(/'/g, "'\\''");
+    execSync(
+      `docker exec ${containerName} sh -c "cat > '${skillPath}' << 'NEXUS_EOF'\n${escapedContent}\nNEXUS_EOF"`,
+      { encoding: 'utf8', timeout: 10000 }
+    );
+    return;
+  }
+
+  // Host skill
+  fs.mkdirSync(path.dirname(skillPath), { recursive: true });
+  if (fs.existsSync(skillPath)) {
+    fs.copyFileSync(skillPath, skillPath + '.bak');
+  }
+  fs.writeFileSync(skillPath, content, 'utf8');
+}
+
+export async function POST(request) {
+  const denied = await requireAuthJWT(request);
+  if (denied) return denied;
+
+  try {
+    const { skillPath, content, containerName } = await request.json();
+
+    if (!skillPath || !content) {
+      return NextResponse.json({ error: 'Missing skillPath or content' }, { status: 400 });
+    }
+
+    // Validate path ends with SKILL.md
+    if (!skillPath.endsWith('SKILL.md')) {
+      return NextResponse.json({ error: 'Only SKILL.md files can be saved' }, { status: 403 });
+    }
+
+    // Determine if this is a shared, bundled, or container skill
+    const absPath = path.resolve(skillPath);
+    const absShared = path.resolve(SHARED_SKILLS_DIR);
+    const absBundled = path.resolve(BUNDLED_SKILLS_DIR);
+
+    const isShared = absPath.startsWith(absShared + path.sep) || absPath === absShared;
+    const isBundled = absPath.startsWith(absBundled + path.sep) || absPath === absBundled;
+    const isContainer = !!containerName;
+
+    if (isBundled) {
+      return NextResponse.json({ error: 'Bundled skills are read-only' }, { status: 403 });
+    }
+
+    if (!isShared && !isContainer) {
+      return NextResponse.json({ error: 'Path not in allowed roots and no containerName provided' }, { status: 403 });
+    }
+
+    writeSkillContent(isContainer ? skillPath : absPath, containerName || null, content);
+
+    return NextResponse.json({ ok: true, saved: isContainer ? skillPath : absPath });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'Internal error';
+    const status = err.status || 500;
+    return NextResponse.json({ error: msg }, { status });
+  }
+}
+
+export async function GET(request) {
+  const denied = await requireAuthJWT(request);
+  if (denied) return denied;
+
+  const { searchParams } = new URL(request.url);
+  const skillPath = searchParams.get('path');
+  const containerName = searchParams.get('containerName');
+
+  if (!skillPath) {
+    return NextResponse.json({ error: 'Missing path' }, { status: 400 });
+  }
+
+  try {
+    if (containerName) {
+      // Read from container via docker exec
+      const content = readSkillContent(skillPath, containerName);
+      return NextResponse.json({ content });
+    }
+
+    // Read from host path
+    const absPath = path.resolve(skillPath);
+    const absShared = path.resolve(SHARED_SKILLS_DIR);
+    const absBundled = path.resolve(BUNDLED_SKILLS_DIR);
+
+    const isShared = absPath.startsWith(absShared + path.sep) || absPath === absShared;
+    const isBundled = absPath.startsWith(absBundled + path.sep) || absPath === absBundled;
+
+    if (!isShared && !isBundled) {
+      return NextResponse.json({ error: 'Host path not in allowed skill roots' }, { status: 403 });
+    }
+
+    const content = readSkillContent(absPath, null);
+    return NextResponse.json({ content });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'Internal error';
+    const status = err.status || 404;
+    return NextResponse.json({ error: msg }, { status });
+  }
+}

package/app/api/stats/route.ts

@@ -0,0 +1,34 @@
+import { NextResponse, type NextRequest } from 'next/server';
+import { openDb } from '@/lib/db';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  try {
+    const db = openDb();
+    const now = new Date();
+    const startOfMonth = Math.floor(
+      new Date(now.getFullYear(), now.getMonth(), 1).getTime() / 1000,
+    );
+    const total = db
+      .prepare(
+        `SELECT COALESCE(SUM(cost_usd),0) as total, COALESCE(SUM(tokens_in),0) as total_in,
+         COALESCE(SUM(tokens_out),0) as total_out, COUNT(*) as sessions
+         FROM sessions WHERE started_at >= ?`,
+      )
+      .get(startOfMonth);
+    const byModel = db
+      .prepare(
+        `SELECT model, COALESCE(SUM(cost_usd),0) as cost,
+         COALESCE(SUM(tokens_in),0) as tokens_in, COALESCE(SUM(tokens_out),0) as tokens_out,
+         COUNT(*) as sessions FROM sessions WHERE started_at >= ? GROUP BY model ORDER BY cost DESC`,
+      )
+      .all(startOfMonth);
+    db.close();
+    return NextResponse.json({ total, byModel });
+  } catch (e: unknown) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}

package/app/api/stats-since/route.ts

@@ -0,0 +1,20 @@
+import { NextResponse, type NextRequest } from 'next/server';
+import { openDb } from '@/lib/db';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  const ts = Number.parseInt(new URL(request.url).searchParams.get('ts') ?? '0', 10);
+  try {
+    const db = openDb();
+    const row = db
+      .prepare('SELECT COALESCE(SUM(cost_usd),0) as total FROM sessions WHERE started_at >= ?')
+      .get(Math.floor(ts / 1000)) as { total: number } | undefined;
+    db.close();
+    return NextResponse.json({ total: row?.total ?? 0 });
+  } catch (e: unknown) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}

package/app/api/stream/route.ts

@@ -0,0 +1,70 @@
+import { type NextRequest } from 'next/server';
+import { DB_PATH } from '@/lib/db';
+import Database from 'better-sqlite3';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(request: NextRequest): Promise<Response> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  let lastEventId = 0;
+  const encoder = new TextEncoder();
+
+  const stream = new ReadableStream({
+    start(controller) {
+      const send = (data: unknown) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}\n\n`));
+      };
+
+      const poll = () => {
+        try {
+          const db = new Database(DB_PATH, { readonly: true });
+          const newEvents = db
+            .prepare(
+              `SELECT e.*, s.label AS session_label FROM events e
+               LEFT JOIN sessions s ON e.session_id = s.session_id
+               WHERE e.id > ? ORDER BY e.ts ASC LIMIT 20`,
+            )
+            .all(lastEventId) as { id: number }[];
+          const sessions = db
+            .prepare(`SELECT s.*, l.label AS lineage_label, l.agent_name AS lineage_agent_name
+                      FROM sessions s
+                      LEFT JOIN lineage l ON s.session_id = l.child_id
+                      ORDER BY s.started_at DESC LIMIT 100`)
+            .all();
+          const costs = db
+            .prepare('SELECT SUM(cost_usd) AS today FROM sessions WHERE started_at >= ?')
+            .get(Math.floor(new Date().setHours(0, 0, 0, 0) / 1000)) as
+            | { today: number | null }
+            | undefined;
+          db.close();
+
+          if (newEvents.length > 0) {
+            lastEventId = newEvents[newEvents.length - 1].id;
+            send({ type: 'events', data: newEvents });
+          }
+          send({ type: 'sessions', data: sessions });
+          send({ type: 'costs', data: { today: costs?.today ?? 0 } });
+        } catch {
+          // Ignore DB read errors to keep stream alive.
+        }
+      };
+
+      poll();
+      const interval = setInterval(poll, 5000);
+
+      request.signal.addEventListener('abort', () => {
+        clearInterval(interval);
+        controller.close();
+      });
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      Connection: 'keep-alive',
+    },
+  });
+}