@flame0510/project-aether 1.1.9

package/scripts/check-providers.mjs

@@ -0,0 +1,143 @@
+import { chromium } from '@playwright/test';
+import http from 'http';
+
+/**
+ * Playwright check: providers page, Atlas agent, DeepSeek key visibility.
+ * Uses existing session cookie from login.
+ */
+
+const BASE = 'http://127.0.0.1:3740';
+const PASSWORD = process.env.REV4A_PASSWORD || '';
+
+function postLogin() {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify({ password: PASSWORD });
+    const req = http.request(`${BASE}/api/auth/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) },
+    }, (res) => {
+      let body = '';
+      res.on('data', (c) => body += c);
+      res.on('end', () => {
+        const cookies = (res.headers['set-cookie'] || []).join('; ');
+        const token = cookies.match(/rev4a_token=([^;]+)/)?.[1];
+        resolve(token ? { token, cookie: cookies } : null);
+      });
+    });
+    req.on('error', reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+async function getAgentProviders(cookie) {
+  return new Promise((resolve, reject) => {
+    http.get(`${BASE}/api/agent-providers`, { headers: { Cookie: cookie } }, (res) => {
+      let body = '';
+      res.on('data', (c) => body += c);
+      res.on('end', () => {
+        try { resolve(JSON.parse(body)); } catch { resolve(null); }
+      });
+    }).on('error', reject);
+  });
+}
+
+(async () => {
+  console.log('=== Provider check script ===\n');
+
+  // 1. Login and get session cookie
+  const login = await postLogin();
+  if (!login) {
+    console.log('FAIL: could not login');
+    process.exit(1);
+  }
+  console.log('OK: logged in');
+
+  // 2. Check API agent-providers returns Atlas with deepseek
+  const agents = await getAgentProviders(login.cookie);
+  if (!agents) {
+    console.log('FAIL: /api/agent-providers returned null');
+    process.exit(1);
+  }
+  console.log(`Found ${agents.length} agent(s):`);
+  let atlasDeepseekCount = 0;
+  for (const a of agents) {
+    const providerNames = (a.providers || []).map(p => p.provider).join(', ');
+    console.log(`  ${a.agentId}: ${providerNames || '(none)'}`);
+    if (a.agentId === 'openclaw-atlas') {
+      for (const p of (a.providers || [])) {
+        if (p.provider === 'deepseek') atlasDeepseekCount++;
+      }
+    }
+  }
+
+  if (atlasDeepseekCount === 0) {
+    console.log('\nWARN: deepseek NOT found in Atlas via API. UI will show it inactive.\n');
+  } else {
+    console.log(`\nOK: deepseek found in Atlas (${atlasDeepseekCount} entry)\n`);
+  }
+
+  // 3. Playwright: headless browser visit providers page with cookie
+  const browser = await chromium.launch({ headless: true, args: ['--no-sandbox'] });
+  const context = await browser.newContext();
+  // Set the rev4a_token cookie manually for the domain
+  await context.addCookies([{
+    name: 'rev4a_token',
+    value: login.token,
+    domain: '127.0.0.1',
+    path: '/',
+    httpOnly: true,
+    sameSite: 'Lax',
+  }]);
+  const page = await context.newPage();
+
+  console.log('Navigating to providers page...');
+  await page.goto(`${BASE}/providers`, { waitUntil: 'networkidle' });
+  // Wait a moment for agent loading
+  await page.waitForTimeout(2000);
+
+  // 4. Check page has agent selector
+  const selectors = await page.locator('select').count();
+  console.log(`Select dropdowns found: ${selectors}`);
+
+  // Try to select Atlas from dropdown
+  const selects = page.locator('select');
+  const selectCount = await selects.count();
+  if (selectCount > 0) {
+    // First select is usually the agent selector
+    const firstSelect = selects.first();
+    const options = await firstSelect.locator('option').allTextContents();
+    console.log(`Agent options: ${options.join(', ')}`);
+
+    if (options.some(o => o.includes('atlas'))) {
+      console.log('OK: Atlas option found in selector');
+      await firstSelect.selectOption(options.find(o => o.includes('atlas')) || options[1]);
+      await page.waitForTimeout(2000);
+
+      // Check for deepseek in visible text
+      const bodyText = await page.locator('body').innerText();
+      const hasDeepseek = bodyText.toLowerCase().includes('deepseek');
+      console.log(`Deepseek visible on page after selecting Atlas: ${hasDeepseek ? 'YES' : 'NO'}`);
+
+      // Look for active indicators
+      const activeElements = page.locator('text=ACTIVE');
+      const activeCount = await activeElements.count();
+      console.log(`"ACTIVE" text occurrences: ${activeCount}`);
+    } else {
+      console.log('WARN: Atlas option NOT found in agent selector');
+    }
+  } else {
+    console.log('WARN: no selector found on page');
+  }
+
+  // 5. Screenshot for visual inspection
+  await page.screenshot({ path: '/tmp/providers-atlas-check.png', fullPage: false });
+  console.log('Screenshot saved to /tmp/providers-atlas-check.png');
+
+  await browser.close();
+  console.log('\n=== Check complete ===');
+
+  // Exit with status: 0 if deepseek visible, 1 if not
+  const finalBody = await page.locator('body').innerText().catch(() => '');
+  process.exit(finalBody.toLowerCase().includes('deepseek') && atlasDeepseekCount > 0 ? 0 : 1);
+})();

package/scripts/docker/traefik/docker-compose.yml

@@ -0,0 +1,32 @@
+# Rev4a Traefik — dedicated reverse proxy
+#
+# This Traefik instance is isolated from any other Traefik running on the host.
+# It uses its own Docker network (rev4a-traefik) and config directory.
+#
+# Ports:
+#   80  → HTTP  (entrypoint: web)
+#   443 → HTTPS (entrypoint: websecure)
+#   8080 → Dashboard (internal only, not exposed)
+
+services:
+  traefik:
+    image: traefik:latest
+    container_name: traefik-'rev4a'
+    restart: unless-stopped
+    ports:
+      - "80:80"
+      - "443:443"
+    networks:
+      - rev4a-traefik
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock:ro
+      - ./traefik.yml:/etc/traefik/traefik.yml:ro
+      - ./dynamic:/etc/traefik/dynamic:ro
+      - ./certs:/etc/traefik/certs
+    labels:
+      - "traefik.enable=false"
+
+networks:
+  rev4a-traefik:
+    name: rev4a-traefik
+    external: true  # created by setup.sh before this Compose stack starts

package/scripts/docker/traefik/dynamic/.gitkeep

@@ -0,0 +1,18 @@
+# Add dynamic Traefik routes here.
+# Files in this directory are watched and applied automatically.
+#
+# Example: route rev4a.yourdomain.com to the Rev4a dashboard:
+#
+# http:
+#   routers:
+#     rev4a-dashboard:
+#       entryPoints: [websecure]
+#       rule: "Host(`rev4a.yourdomain.com`)"
+#       service: rev4a
+#       tls:
+#         certResolver: letsencrypt
+#   services:
+#     rev4a:
+#       loadBalancer:
+#         servers:
+#           - url: "http://127.0.0.1:3740"

package/scripts/docker/traefik/traefik.yml

@@ -0,0 +1,37 @@
+# Traefik static configuration
+# See: https://doc.traefik.io/traefik/reference/static-configuration/file/
+
+global:
+  checkNewVersion: false
+  sendAnonymousUsage: false
+
+log:
+  level: WARN
+
+api:
+  dashboard: true
+  insecure: false
+
+entryPoints:
+  web:
+    address: ":80"
+  websecure:
+    address: ":443"
+
+providers:
+  docker:
+    endpoint: "unix:///var/run/docker.sock"
+    exposedByDefault: false
+    network: rev4a-traefik
+
+  file:
+    directory: /etc/traefik/dynamic
+    watch: true
+
+certificatesResolvers:
+  letsencrypt:
+    acme:
+      email: "admin@example.com"  # CHANGE THIS to your real email before enabling HTTPS
+      storage: /etc/traefik/certs/acme.json
+      httpChallenge:
+        entryPoint: web

package/scripts/remove-auth-profile.js

@@ -0,0 +1,56 @@
+/**
+ * Remove an auth profile from the OpenClaw SQLite database.
+ * Usage: node remove-auth-profile.js <db-path> <provider-name>
+ *
+ * Reads the store_json from auth_profile_store, removes any profiles
+ * matching the provider, and writes back.
+ */
+const { execSync: run } = require('child_process');
+
+const db = process.argv[2];
+const provider = process.argv[3];
+
+if (!db || !provider) {
+  process.stderr.write('Usage: node remove-auth-profile.js <db-path> <provider>\n');
+  process.exit(1);
+}
+
+try {
+  const row = run(
+    'sqlite3 ' + JSON.stringify(db) + ' "SELECT store_json FROM auth_profile_store WHERE store_key=\'primary\'"',
+    { encoding: 'utf8', timeout: 5000 }
+  ).trim();
+
+  if (!row) process.exit(0);
+
+  const data = JSON.parse(row);
+  if (!data.profiles) process.exit(0);
+
+  let changed = false;
+  for (const pid of Object.keys(data.profiles)) {
+    const p = data.profiles[pid];
+    if (p.provider === provider || pid.startsWith(provider + ':')) {
+      delete data.profiles[pid];
+      changed = true;
+      process.stderr.write('Removed profile: ' + pid + '\n');
+    }
+  }
+
+  if (!changed) process.exit(0);
+
+  const newJson = JSON.stringify(data);
+  // Escape single quotes for SQLite shell
+  const escaped = newJson.replace(/'/g, "''");
+  const updateCmd =
+    'sqlite3 ' + JSON.stringify(db) +
+    ' "UPDATE auth_profile_store SET store_json=\'' + escaped +
+    '\', updated_at=' + Date.now() +
+    ' WHERE store_key=\'primary\'"';
+
+  run(updateCmd, { timeout: 5000 });
+  process.stderr.write('Updated auth_profile_store\n');
+  console.log('ok');
+} catch (e) {
+  process.stderr.write('Error: ' + e.message + '\n');
+  process.exit(1);
+}

package/scripts/restore.sh

@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+# restore.sh — Restore Rev4a data from a backup archive
+#
+# Usage:
+#   sudo bash scripts/restore.sh backups/rev4a-backup-20260724-120000.tar.gz
+#
+# The script restores:
+#   - data/*.db
+#   - data/provider-keys.json
+#   - data/agents-token.json
+#   - models.config.json
+#   - .env
+#
+# Existing files are backed up to a .pre-restore directory before overwriting.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REV4A_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+
+ARCHIVE="${1:-}"
+
+if [[ -z "$ARCHIVE" ]]; then
+  echo "Usage: sudo bash scripts/restore.sh <backup-archive.tar.gz>"
+  echo ""
+  echo "Available backups:"
+  if [[ -d "${REV4A_ROOT}/backups" ]]; then
+    ls -lh "${REV4A_ROOT}/backups/"*.tar.gz 2>/dev/null || echo "  (none)"
+  else
+    echo "  (no backups directory)"
+  fi
+  exit 1
+fi
+
+if [[ ! -f "$ARCHIVE" ]]; then
+  echo "Error: Archive not found: $ARCHIVE"
+  exit 1
+fi
+
+echo "Restoring Rev4a from: $ARCHIVE"
+echo ""
+
+# Create pre-restore backup of current state
+PRE_DIR="${REV4A_ROOT}/backups/.pre-restore-$(date -u +%Y%m%d-%H%M%S)"
+mkdir -p "$PRE_DIR"
+
+echo "Saving current state to: $PRE_DIR"
+cd "$REV4A_ROOT"
+for f in data/*.db data/*.db-shm data/*.db-wal data/provider-keys.json data/agents-token.json models.config.json .env; do
+  if [[ -f "$f" ]]; then
+    cp --parents "$f" "$PRE_DIR/" 2>/dev/null || true
+  fi
+done
+
+# Stop Rev4a services before restore
+if systemctl is-active --quiet rev4a.service 2>/dev/null; then
+  echo "Stopping Rev4a services..."
+  sudo systemctl stop rev4a.service
+  echo "Services stopped."
+fi
+
+# Extract the archive
+echo "Extracting backup..."
+tar -xzf "$ARCHIVE" -C "$REV4A_ROOT"
+
+# Fix permissions
+chmod 600 "${REV4A_ROOT}/.env" 2>/dev/null || true
+chmod 600 "${REV4A_ROOT}/data/provider-keys.json" 2>/dev/null || true
+chmod 600 "${REV4A_ROOT}/data/agents-token.json" 2>/dev/null || true
+
+echo ""
+echo "=============================================="
+echo "  Restore complete!"
+echo "=============================================="
+echo ""
+echo "  Previous state saved to: ${PRE_DIR}"
+echo ""
+echo "  To restart Rev4a:"
+echo "    sudo systemctl start rev4a.service"
+echo ""
+echo "  If something went wrong, restore previous state from:"
+echo "    ${PRE_DIR}"
+echo "=============================================="

package/terminal-ws-server.js

@@ -0,0 +1,139 @@
+// Terminal WebSocket Server — standalone
+// Uses node-pty for real PTY with docker exec - fully interactive
+const { WebSocketServer } = require('ws');
+const http = require('http');
+const path = require('path');
+
+const pty = require(path.resolve(__dirname, 'node_modules/node-pty'));
+
+const PORT = parseInt(process.env.TERMINAL_WS_PORT || '3741', 10);
+const SESSION_TIMEOUT_MS = 30 * 60 * 1000;
+const IDLE_RESET_TIMEOUT_MS = 60 * 1000;
+
+const server = http.createServer((_req, res) => {
+  res.writeHead(426, { 'Content-Type': 'text/plain' });
+  res.end('Use WebSocket');
+});
+
+const wss = new WebSocketServer({ server });
+
+wss.on('connection', (ws, req) => {
+  const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+  const containerId = url.searchParams.get('id');
+
+  if (!containerId) {
+    ws.send(`\r\n[Error: Missing container id]\r\n`);
+    ws.close();
+    return;
+  }
+
+  let term = null;
+  let idleTimer = setTimeout(() => {
+    ws.send('\r\n[Session timeout: 30 minutes]\r\n');
+    try { ws.close(); } catch {}
+  }, SESSION_TIMEOUT_MS);
+
+  function resetIdleTimer() {
+    clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+      ws.send('\r\n[Session timeout: 30 minutes]\r\n');
+      try { ws.close(); } catch {}
+    }, SESSION_TIMEOUT_MS);
+  }
+
+  try {
+    term = pty.spawn('docker', ['exec', '-it', containerId, 'env', 'TERM=xterm-256color', 'bash'], {
+      name: 'xterm-256color',
+      cols: 80,
+      rows: 30,
+    });
+  } catch (err) {
+    ws.send(`\r\n[Error: ${err.message}]\r\n`);
+    ws.close();
+    clearTimeout(idleTimer);
+    return;
+  }
+
+  // PTY output → WebSocket.
+  // Use a queue + micro-delay to avoid flooding xterm.js with one giant chunk.
+  let outputBuf = '';
+  let outputTimer = null;
+
+  function flushOutput() {
+    outputTimer = null;
+    if (!outputBuf) return;
+    if (ws.readyState !== ws.OPEN) { outputBuf = ''; return; }
+    ws.send(outputBuf);
+    outputBuf = '';
+  }
+
+  term.onData((data) => {
+    if (!data) return;
+    outputBuf += data;
+    // Flush every 10ms max (roughly 30-40 chunks/sec — safe for DOM renderer)
+    if (!outputTimer) {
+      outputTimer = setTimeout(flushOutput, 10);
+    }
+    // If buffer grows huge, flush immediately in chunks
+    if (outputBuf.length > 4000) {
+      // Split into 2k chunks
+      while (outputBuf.length > 2000) {
+        const chunk = outputBuf.slice(0, 2000);
+        outputBuf = outputBuf.slice(2000);
+        if (ws.readyState === ws.OPEN) ws.send(chunk);
+      }
+    }
+  });
+
+  // WebSocket input → PTY
+  ws.on('message', (data) => {
+    resetIdleTimer();
+    if (!term) return;
+
+    const msg = data.toString();
+
+    // Handle resize message from client
+    if (msg.startsWith('{"type":"resize"}') || msg.startsWith('{"type":"resize"') && msg.includes('"cols"')) {
+      try {
+        const parsed = JSON.parse(msg);
+        if (parsed.type === 'resize' && parsed.cols && parsed.rows) {
+          term.resize(parsed.cols, parsed.rows);
+        }
+      } catch {}
+      return;
+    }
+
+    term.write(msg);
+  });
+
+  term.onExit(({ exitCode, signal }) => {
+    clearTimeout(idleTimer);
+    if (ws.readyState === ws.OPEN) {
+      ws.send(`\r\n[Process exited with code ${exitCode}]\r\n`);
+      ws.close();
+    }
+  });
+
+  ws.on('close', () => {
+    clearTimeout(idleTimer);
+    if (term) term.kill('SIGTERM');
+  });
+
+  ws.on('error', () => {
+    clearTimeout(idleTimer);
+    if (term) term.kill('SIGTERM');
+  });
+
+  term.write('\n');
+  ws.send(`\r\n[Connected to container: ${containerId}]\r\n`);
+});
+
+server.listen(PORT, '127.0.0.1', () => {
+  console.log(`[TerminalWS] Server listening on ws://127.0.0.1:${PORT}`);
+});
+
+process.on('SIGTERM', () => {
+  console.log('[TerminalWS] Shutting down...');
+  wss.close();
+  server.close(() => process.exit(0));
+});

package/tsconfig.json

@@ -0,0 +1,42 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": [
+        "./*"
+      ]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    ".next/dev/dev/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}