@flame0510/project-aether 1.1.9

package/lib/memory-context.ts

@@ -0,0 +1,385 @@
+import fs from 'fs';
+import path from 'path';
+
+export const OPENCLAW_CONFIG_PATH = '/data/.openclaw/openclaw.json';
+export const SHARED_CONTEXT_DIR = '/data/.openclaw/shared-context';
+export const DEFAULT_WORKSPACE_ROOT = '/data/.openclaw';
+export const BOOTSTRAP_FILES = ['USER.md', 'MEMORY.md', 'AGENTS.md', 'SOUL.md', 'HEARTBEAT.md'] as const;
+export const GLOBAL_CONTEXT_FILES = ['USER.md', 'MEMORY.md', 'AGENTS.md', 'SOUL.md', 'HEARTBEAT.md'] as const;
+export const WORKSPACE_TOTAL_WARN_BYTES = 25 * 1024;
+export const BOOTSTRAP_FILE_WARN_BYTES: Partial<Record<BootstrapFileName, number>> = {
+  'MEMORY.md': 10 * 1024,
+  'SOUL.md': 4 * 1024,
+  'USER.md': 8 * 1024,
+  'AGENTS.md': 10 * 1024,
+  'HEARTBEAT.md': 4 * 1024,
+};
+
+export type BootstrapFileName = (typeof BOOTSTRAP_FILES)[number];
+export type StrategyHealth = 'ok' | 'warning' | 'error';
+
+export interface FileSummary {
+  key: string;
+  path: string;
+  exists: boolean;
+  isSymlink: boolean;
+  symlinkTarget: string | null;
+  size: number | null;
+  mtime: string | null;
+  warnings: string[];
+}
+
+export interface AgentMemorySummary {
+  agentId: string;
+  name: string;
+  displayName?: string;
+  workspace: string;
+  source: string[];
+  files: Record<BootstrapFileName, FileSummary>;
+  bootstrapBytes: number;
+  bootstrapBudgetBytes: number;
+  strategy: {
+    userProfile: 'shared' | 'local' | 'missing';
+    memory: 'local' | 'missing' | 'shared-warning';
+    health: StrategyHealth;
+  };
+  warnings: string[];
+}
+
+export interface MemoryContextPayload {
+  globalContext: FileSummary[];
+  agents: AgentMemorySummary[];
+  strategy: {
+    userProfile: 'shared' | 'local' | 'missing';
+    memory: 'local' | 'missing' | 'shared-warning';
+    health: StrategyHealth;
+    warnings: string[];
+  };
+  summary: {
+    totalAgents: number;
+    userLinked: number;
+    warnings: number;
+    globalFiles: number;
+  };
+  warnings: string[];
+}
+
+interface ConfigAgent {
+  id?: unknown;
+  name?: unknown;
+  workspace?: unknown;
+}
+
+interface OpenClawConfig {
+  agents?: {
+    list?: ConfigAgent[];
+    defaults?: {
+      workspace?: unknown;
+    };
+  };
+}
+
+interface AgentSeed {
+  agentId: string;
+  name: string;
+  displayName?: string;
+  workspace: string;
+  source: Set<string>;
+}
+
+function toIsoTime(value: Date | null): string | null {
+  return value ? value.toISOString() : null;
+}
+
+function normalizeAgentIdFromWorkspace(workspace: string): string {
+  const base = path.basename(workspace);
+  if (base === 'workspace') return 'default';
+  if (base.startsWith('workspace-')) return base.slice('workspace-'.length) || 'unknown';
+  return base || 'unknown';
+}
+
+function safeReadConfigWarnings(warnings: string[]): OpenClawConfig {
+  if (!fs.existsSync(OPENCLAW_CONFIG_PATH)) {
+    warnings.push(`OpenClaw config missing: ${OPENCLAW_CONFIG_PATH}`);
+    return {};
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(OPENCLAW_CONFIG_PATH, 'utf8')) as OpenClawConfig;
+  } catch (error) {
+    warnings.push(`Unable to parse openclaw.json: ${(error as Error).message}`);
+    return {};
+  }
+}
+
+function uniqueStrings(values: string[]): string[] {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function formatBytesForWarning(value: number): string {
+  if (value < 1024) return `${value} B`;
+  return `${(value / 1024).toFixed(1)} KB`;
+}
+
+function applyBootstrapSizeWarnings(file: FileSummary): void {
+  const limit = BOOTSTRAP_FILE_WARN_BYTES[file.key as BootstrapFileName];
+  if (!limit || file.size === null || file.size <= limit) return;
+  file.warnings.push(`${file.key} sopra soglia: ${formatBytesForWarning(file.size)} / ${formatBytesForWarning(limit)}`);
+}
+
+export function inspectFile(filePath: string, key: string): FileSummary {
+  const warnings: string[] = [];
+  let exists = false;
+  let isSymlink = false;
+  let symlinkTarget: string | null = null;
+  let size: number | null = null;
+  let mtime: string | null = null;
+
+  try {
+    const lst = fs.lstatSync(filePath);
+    exists = true;
+    isSymlink = lst.isSymbolicLink();
+
+    if (isSymlink) {
+      try {
+        const linkValue = fs.readlinkSync(filePath);
+        symlinkTarget = path.resolve(path.dirname(filePath), linkValue);
+      } catch (error) {
+        warnings.push(`Unable to resolve symlink: ${(error as Error).message}`);
+      }
+    }
+
+    try {
+      const stat = fs.statSync(filePath);
+      size = stat.size;
+      mtime = toIsoTime(stat.mtime);
+    } catch (error) {
+      warnings.push(`Unable to stat target: ${(error as Error).message}`);
+    }
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code !== 'ENOENT') warnings.push(`Unable to inspect file: ${(error as Error).message}`);
+  }
+
+  const summary = {
+    key,
+    path: filePath,
+    exists,
+    isSymlink,
+    symlinkTarget,
+    size,
+    mtime,
+    warnings,
+  };
+  applyBootstrapSizeWarnings(summary);
+  return summary;
+}
+
+function inspectGlobalContext(warnings: string[]): FileSummary[] {
+  if (!fs.existsSync(SHARED_CONTEXT_DIR)) {
+    warnings.push(`Shared context directory missing: ${SHARED_CONTEXT_DIR}`);
+  }
+
+  return GLOBAL_CONTEXT_FILES.map((fileName) => {
+    const summary = inspectFile(path.join(SHARED_CONTEXT_DIR, fileName), fileName);
+    if (!fs.existsSync(SHARED_CONTEXT_DIR)) {
+      summary.warnings.push('Shared context directory not found');
+    }
+    return summary;
+  });
+}
+
+function discoverAgents(globalWarnings: string[]): AgentSeed[] {
+  const config = safeReadConfigWarnings(globalWarnings);
+  const defaultWorkspace = typeof config.agents?.defaults?.workspace === 'string' && config.agents.defaults.workspace.trim()
+    ? config.agents.defaults.workspace.trim()
+    : path.join(DEFAULT_WORKSPACE_ROOT, 'workspace');
+
+  const seeds = new Map<string, AgentSeed>();
+
+  const upsert = (agentId: string, name: string, workspace: string, source: string, displayName?: string) => {
+    const cleanWorkspace = workspace.trim();
+    if (!cleanWorkspace) return;
+    const key = `${agentId}@@${cleanWorkspace}`;
+    const existing = seeds.get(key);
+    if (existing) {
+      existing.source.add(source);
+      if (existing.name === existing.agentId && name) existing.name = name;
+      if (displayName && !existing.displayName) existing.displayName = displayName;
+      return;
+    }
+    seeds.set(key, {
+      agentId,
+      name: name || agentId,
+      displayName,
+      workspace: cleanWorkspace,
+      source: new Set([source]),
+    });
+  };
+
+  for (const agent of config.agents?.list ?? []) {
+    const agentId = typeof agent.id === 'string' && agent.id.trim() ? agent.id.trim() : '';
+    if (!agentId) continue;
+    const agentName = typeof agent.name === 'string' && agent.name.trim() ? agent.name.trim() : agentId;
+    const workspace = typeof agent.workspace === 'string' && agent.workspace.trim() ? agent.workspace.trim() : defaultWorkspace;
+    upsert(agentId, agentName, workspace, 'config');
+  }
+
+  try {
+    for (const entry of fs.readdirSync(DEFAULT_WORKSPACE_ROOT, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name !== 'workspace' && !entry.name.startsWith('workspace-')) continue;
+      const workspace = path.join(DEFAULT_WORKSPACE_ROOT, entry.name);
+      const agentId = normalizeAgentIdFromWorkspace(workspace);
+      upsert(agentId, agentId, workspace, 'filesystem');
+    }
+  } catch (error) {
+    globalWarnings.push(`Unable to scan workspaces: ${(error as Error).message}`);
+  }
+
+  // Discover Docker agents with AGENT_ID label (Rev4a-managed containers)
+  try {
+    const { execSync } = require('child_process');
+    const out = execSync(
+      `docker ps --filter "label=AGENT_ID" --format '{{.Names}}|{{.Label "AGENT_ID"}}'`,
+      { timeout: 5000, encoding: 'utf-8' },
+    ).trim();
+    if (out) {
+      for (const line of out.split('\n')) {
+        const [containerName, agentId] = line.split('|');
+        if (!containerName || !agentId) continue;
+        // Read AGENT_NAME from container env
+        let displayName = '';
+        try {
+          displayName = execSync(
+            `docker exec ${containerName} sh -c 'printenv AGENT_NAME'`,
+            { timeout: 3000, encoding: 'utf-8' },
+          ).trim();
+        } catch { /* env read failed — use fallback */ }
+        const workspace = '/root/.openclaw/workspace/';
+        upsert(agentId, displayName || containerName, workspace, 'docker', displayName || undefined);
+      }
+    }
+  } catch {
+    // Docker not available — not a fatal error for memory context
+  }
+
+  if (!seeds.size) {
+    upsert('default', 'default', defaultWorkspace, 'defaults');
+  }
+
+  return [...seeds.values()].sort((a, b) => a.agentId.localeCompare(b.agentId));
+}
+
+function classifyAgent(summary: AgentMemorySummary): AgentMemorySummary['strategy'] {
+  const user = summary.files['USER.md'];
+  const memory = summary.files['MEMORY.md'];
+
+  const userProfile = !user.exists
+    ? 'missing'
+    : user.isSymlink && user.symlinkTarget?.startsWith(`${SHARED_CONTEXT_DIR}${path.sep}`)
+      ? 'shared'
+      : 'local';
+
+  const memoryStatus = !memory.exists
+    ? 'missing'
+    : memory.isSymlink && memory.symlinkTarget?.startsWith(`${SHARED_CONTEXT_DIR}${path.sep}`)
+      ? 'shared-warning'
+      : 'local';
+
+  if (userProfile === 'missing') summary.warnings.push('USER.md missing');
+  if (memoryStatus === 'missing') summary.warnings.push('MEMORY.md missing');
+  if (memoryStatus === 'shared-warning') summary.warnings.push('MEMORY.md should stay local, not shared');
+
+  for (const fileName of ['AGENTS.md', 'SOUL.md'] as const) {
+    if (!summary.files[fileName].exists) summary.warnings.push(`${fileName} missing`);
+  }
+
+  const allWarnings = uniqueStrings(summary.warnings.concat(...Object.values(summary.files).map((file) => file.warnings)));
+  const hasStructuralWarning = allWarnings.some((warning) => /should stay local|missing/.test(warning));
+  const health: StrategyHealth = hasStructuralWarning
+    ? allWarnings.length >= 3 || userProfile === 'missing'
+      ? 'error'
+      : 'warning'
+    : allWarnings.length > 0
+      ? 'warning'
+      : 'ok';
+
+  return { userProfile, memory: memoryStatus, health };
+}
+
+function inspectAgent(seed: AgentSeed): AgentMemorySummary {
+  const files = Object.fromEntries(
+    BOOTSTRAP_FILES.map((fileName) => [fileName, inspectFile(path.join(seed.workspace, fileName), fileName)]),
+  ) as Record<BootstrapFileName, FileSummary>;
+
+  const bootstrapBytes = Object.values(files).reduce((total, file) => total + (file.size ?? 0), 0);
+
+  const summary: AgentMemorySummary = {
+    agentId: seed.agentId,
+    name: seed.name,
+    displayName: seed.displayName,
+    workspace: seed.workspace,
+    source: [...seed.source].sort(),
+    files,
+    bootstrapBytes,
+    bootstrapBudgetBytes: WORKSPACE_TOTAL_WARN_BYTES,
+    strategy: {
+      userProfile: 'missing',
+      memory: 'missing',
+      health: 'error',
+    },
+    warnings: [],
+  };
+
+  summary.strategy = classifyAgent(summary);
+  if (bootstrapBytes > WORKSPACE_TOTAL_WARN_BYTES) {
+    summary.warnings.push(`Bootstrap totale sopra budget: ${formatBytesForWarning(bootstrapBytes)} / ${formatBytesForWarning(WORKSPACE_TOTAL_WARN_BYTES)}`);
+  }
+  summary.warnings = uniqueStrings(summary.warnings.concat(...Object.values(files).map((file) => file.warnings)));
+  return summary;
+}
+
+export function getMemoryContextSnapshot(): MemoryContextPayload {
+  const warnings: string[] = [];
+  const globalContext = inspectGlobalContext(warnings);
+  const agents = discoverAgents(warnings).map(inspectAgent);
+
+  const allAgentWarnings = agents.flatMap((agent) => agent.warnings);
+  const healths = agents.map((agent) => agent.strategy.health);
+  const topHealth: StrategyHealth = healths.includes('error')
+    ? 'error'
+    : healths.includes('warning') || warnings.length > 0 || globalContext.some((file) => file.warnings.length > 0)
+      ? 'warning'
+      : 'ok';
+
+  const topUserProfile = agents.some((agent) => agent.strategy.userProfile === 'shared')
+    ? 'shared'
+    : agents.some((agent) => agent.strategy.userProfile === 'local')
+      ? 'local'
+      : 'missing';
+
+  const topMemory = agents.some((agent) => agent.strategy.memory === 'shared-warning')
+    ? 'shared-warning'
+    : agents.some((agent) => agent.strategy.memory === 'local')
+      ? 'local'
+      : 'missing';
+
+  return {
+    globalContext,
+    agents,
+    strategy: {
+      userProfile: topUserProfile,
+      memory: topMemory,
+      health: topHealth,
+      warnings: uniqueStrings(warnings.concat(allAgentWarnings, ...globalContext.map((file) => file.warnings))),
+    },
+    summary: {
+      totalAgents: agents.length,
+      userLinked: agents.filter((agent) => agent.strategy.userProfile === 'shared').length,
+      warnings: uniqueStrings(warnings.concat(allAgentWarnings, ...globalContext.map((file) => file.warnings))).length,
+      globalFiles: globalContext.filter((file) => file.exists).length,
+    },
+    warnings: uniqueStrings(warnings),
+  };
+}

package/lib/model-catalogue.ts

@@ -0,0 +1,131 @@
+/**
+ * Model catalogue — bundle-first + user-overrides.
+ *
+ * Reads the bundled models.config.json from the npm package and applies
+ * user toggles from REV4A_DATA/model-overrides.json.
+ *
+ * Imported by both provider/route.ts and gateway/sync.ts — shared logic,
+ * avoids circular dependencies.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { REV4A_DATA } from '@/lib/rev4a-paths';
+
+/* ------------------------------------------------------------------ */
+/*  Types                                                              */
+/* ------------------------------------------------------------------ */
+
+export interface ModelConfigEntry {
+  id: string;
+  name: string;
+  provider: string;
+  enabled: boolean;
+  modality?: string;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Path helpers                                                        */
+/* ------------------------------------------------------------------ */
+
+/** Absolute path to model-overrides.json in REV4A_DATA. */
+function overridesPath(): string {
+  return path.join(REV4A_DATA, 'model-overrides.json');
+}
+
+/** Resolve the bundled models.config.json (in the npm package). */
+function resolveBundledPath(): string {
+  // cwd first (works with systemd WorkingDirectory pointed at the repo / project)
+  const cwdPath = path.resolve(process.cwd(), 'models.config.json');
+  if (fs.existsSync(cwdPath)) return cwdPath;
+  // Fallback: relative to this module (lib/ → project root)
+  return path.resolve(__dirname, '..', 'models.config.json');
+}
+
+/* ------------------------------------------------------------------ */
+/*  Loaders                                                             */
+/* ------------------------------------------------------------------ */
+
+function loadBundledModels(): ModelConfigEntry[] {
+  try {
+    const raw = fs.readFileSync(resolveBundledPath(), 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed.models)) {
+      return parsed.models.map((m: Record<string, unknown>) => ({
+        id: String(m.id ?? ''),
+        name: String(m.name ?? ''),
+        provider: String(m.provider ?? ''),
+        enabled: Boolean(m.enabled),
+        modality: typeof m.modality === 'string' ? m.modality : undefined,
+      }));
+    }
+  } catch { /* fall through */ }
+  return [];
+}
+
+export function loadOverrides(): Record<string, boolean> {
+  try {
+    if (!fs.existsSync(overridesPath())) return {};
+    const raw = fs.readFileSync(overridesPath(), 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      const out: Record<string, boolean> = {};
+      for (const [k, v] of Object.entries(parsed)) {
+        if (typeof v === 'boolean') out[k] = v;
+      }
+      return out;
+    }
+  } catch { /* ignore */ }
+  return {};
+}
+
+export function writeOverrides(overrides: Record<string, boolean>): void {
+  if (!fs.existsSync(REV4A_DATA)) {
+    fs.mkdirSync(REV4A_DATA, { recursive: true });
+  }
+  fs.writeFileSync(overridesPath(), JSON.stringify(overrides, null, 2), 'utf-8');
+}
+
+/**
+ * Load the full model catalogue:
+ * 1. Read models.config.json from the npm package (bundle).
+ * 2. Apply user overrides (enabled/disabled toggles).
+ *
+ * The bundle is read-only at runtime. User choices live in model-overrides.json.
+ */
+export function loadModelsConfig(): ModelConfigEntry[] {
+  const bundled = loadBundledModels();
+  const overrides = loadOverrides();
+
+  // Clean up orphan overrides (models removed from bundle)
+  const bundledIds = new Set(bundled.map((m) => m.id));
+  let dirty = false;
+  for (const id of Object.keys(overrides)) {
+    if (!bundledIds.has(id)) {
+      delete overrides[id];
+      dirty = true;
+    }
+  }
+  if (dirty) writeOverrides(overrides);
+
+  return bundled.map((m) => ({
+    ...m,
+    enabled: Object.prototype.hasOwnProperty.call(overrides, m.id) ? overrides[m.id] : m.enabled,
+  }));
+}
+
+/** Save a single model toggle (writes to model-overrides.json). */
+export function toggleModelOverride(modelId: string, enabled: boolean): boolean {
+  const overrides = loadOverrides();
+  const bundled = loadBundledModels();
+  const bm = bundled.find((m) => m.id === modelId);
+  if (!bm) return false; // unknown model
+
+  if (enabled === bm.enabled) {
+    // Reset to default → remove key (keeps file clean)
+    delete overrides[modelId];
+  } else {
+    overrides[modelId] = enabled;
+  }
+  writeOverrides(overrides);
+  return true;
+}

package/lib/model-pricing.ts

@@ -0,0 +1,63 @@
+/**
+ * Model pricing data — static, from model-pricing.json in the project root.
+ *
+ * OpenRouter models are NOT included here; their pricing is fetched live
+ * via the OpenRouter API and merged client-side.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface ModelPricing {
+  input: number;
+  output: number;
+}
+
+let _cache: Record<string, ModelPricing> | null = null;
+let _cacheMtime = 0;
+
+function resolvePricingPath(): string {
+  // Try cwd first (works with systemd WorkingDirectory)
+  const cwdPath = path.resolve(process.cwd(), 'model-pricing.json');
+  if (fs.existsSync(cwdPath)) return cwdPath;
+  // Fallback: relative to this module (works for npm global installs)
+  return path.resolve(__dirname, '..', 'model-pricing.json');
+}
+
+const PRICING_PATH = resolvePricingPath();
+
+function load(): Record<string, ModelPricing> {
+  try {
+    const stat = fs.statSync(PRICING_PATH);
+    if (_cache && stat.mtimeMs <= _cacheMtime) return _cache;
+    const raw = fs.readFileSync(PRICING_PATH, 'utf-8');
+    _cache = JSON.parse(raw) as Record<string, ModelPricing>;
+    _cacheMtime = stat.mtimeMs;
+    return _cache!;
+  } catch {
+    return {};
+  }
+}
+
+/** Get pricing for a single model, or null if not found. */
+export function getPricing(modelId: string): ModelPricing | null {
+  const all = load();
+  return all[modelId] ?? null;
+}
+
+/** Get all static pricing entries. */
+export function getAllPricing(): Record<string, ModelPricing> {
+  return { ...load() };
+}
+
+/** Format pricing for display: "$0.44 / $0.87" or "Free" or "Dynamic" or "—" */
+export function formatPricing(p: ModelPricing | null | undefined): string {
+  if (!p) return '—';
+  if (p.input === -1 && p.output === -1) return 'Dynamic';
+  if (p.input === 0 && p.output === 0) return 'Free';
+  const fmt = (n: number) => {
+    if (n < 0.01) return `$${n.toFixed(3)}`;
+    if (n < 1) return `$${n.toFixed(2)}`;
+    return `$${n.toFixed(2)}`;
+  };
+  return `${fmt(p.input)} / ${fmt(p.output)}`;
+}