@flame0510/project-aether 1.1.9

package/lib/openclaw-cron.ts

@@ -0,0 +1,350 @@
+import { execFileSync } from 'child_process';
+
+// ── Types ─────────────────────────────────────────────────────────────────
+
+export interface CronSchedule {
+  kind?: string;
+  expr?: string;
+  tz?: string;
+  [key: string]: unknown;
+}
+
+export interface CronPayload {
+  kind?: string;
+  text?: string;
+  message?: string;
+  model?: string;
+  fallbacks?: string[];
+  [key: string]: unknown;
+}
+
+export interface CronState {
+  lastStatus?: string;
+  nextRunAtMs?: number | null;
+  lastRunAtMs?: number | null;
+  [key: string]: unknown;
+}
+
+export interface OpenClawCronJob {
+  id?: string;
+  name?: string;
+  description?: string;
+  agentId?: string;
+  containerName?: string;
+  enabled?: boolean;
+  schedule?: CronSchedule;
+  scheduleExpr?: string;
+  state?: CronState;
+  payload?: CronPayload;
+  createdAtMs?: number;
+  updatedAtMs?: number;
+  sessionTarget?: string;
+  wakeMode?: string;
+  source?: 'host' | 'container';
+  delivery?: {
+    mode?: string;
+    channel?: string;
+    to?: string;
+    accountId?: string;
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+
+export interface OpenClawCronListResult {
+  ok: boolean;
+  jobs: OpenClawCronJob[];
+  total: number;
+}
+
+export interface AgentInfo {
+  agentId: string;
+  containerName: string;
+}
+
+// ── Extract schedule expression ──────────────────────────────────────────
+
+function extractScheduleExpr(job: OpenClawCronJob): string {
+  if (job.scheduleExpr) return job.scheduleExpr;
+  if (typeof job.schedule === 'string') return job.schedule;
+  if (job.schedule && typeof job.schedule === 'object') {
+    return (job.schedule as any).expr ?? '';
+  }
+  return '';
+}
+
+// ── Discover agent containers ────────────────────────────────────────────
+
+function discoverAgentContainers(): AgentInfo[] {
+  try {
+    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;
+      let agentId = containerName;
+      try {
+        agentId = execFileSync('docker', [
+          'inspect', containerName, '--format', '{{index .Config.Labels "AGENT_ID"}}'
+        ], { encoding: 'utf8', timeout: 5000 }).trim();
+      } catch { /* fallback */ }
+      return { containerName, agentId: agentId || containerName };
+    }).filter(Boolean) as AgentInfo[];
+  } catch {
+    return [];
+  }
+}
+
+// ── Parse CLI output ─────────────────────────────────────────────────────
+
+function parseCronListOutput(raw: string): OpenClawCronJob[] | null {
+  try {
+    const parsed = JSON.parse(raw.trim()) as unknown;
+    if (Array.isArray(parsed)) return parsed as OpenClawCronJob[];
+    if (parsed && typeof parsed === 'object' && Array.isArray((parsed as { jobs?: unknown[] }).jobs)) {
+      return (parsed as { jobs: OpenClawCronJob[] }).jobs;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function listJobsOnHost(): OpenClawCronJob[] | null {
+  try {
+    const raw = execFileSync('openclaw', ['cron', 'list', '--json', '--all'], {
+      encoding: 'utf8', timeout: 15000,
+    });
+    return parseCronListOutput(raw);
+  } catch {
+    return null;
+  }
+}
+
+function listJobsInContainer(containerName: string): OpenClawCronJob[] | null {
+  // Try both common agent gateway ports. Agents default to 3000 (OpenClaw
+  // gateway --bind lan --port 3000) but may also run on 18789 (default).
+  const gatewayUrls = [
+    'http://127.0.0.1:3000',
+    'http://127.0.0.1:18789',
+  ];
+
+  for (const gwUrl of gatewayUrls) {
+    try {
+      const raw = execFileSync('docker', [
+        'exec', '-e', `OPENCLAW_GATEWAY_URL=${gwUrl}`,
+        containerName, 'openclaw', 'cron', 'list', '--json', '--all',
+      ], { encoding: 'utf8', timeout: 15000 });
+      const parsed = parseCronListOutput(raw);
+      if (parsed) return parsed;
+    } catch { /* try next gateway port */ }
+  }
+
+  return null;
+}
+
+// ── PATCH helpers ────────────────────────────────────────────────────────
+
+function toggleOnHost(jobId: string, enabled: boolean): boolean {
+  try {
+    const action = enabled ? 'enable' : 'disable';
+    execFileSync('openclaw', ['cron', action, jobId], {
+      encoding: 'utf8', timeout: 10000,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function toggleInContainer(containerName: string, jobId: string, enabled: boolean): boolean {
+  const gatewayUrls = [
+    'http://127.0.0.1:3000',
+    'http://127.0.0.1:18789',
+  ];
+  for (const gwUrl of gatewayUrls) {
+    try {
+      const action = enabled ? 'enable' : 'disable';
+      execFileSync('docker', [
+        'exec', '-e', `OPENCLAW_GATEWAY_URL=${gwUrl}`,
+        containerName, 'openclaw', 'cron', action, jobId,
+      ], { encoding: 'utf8', timeout: 10000 });
+      return true;
+    } catch { /* try next gateway port */ }
+  }
+  return false;
+}
+
+// ── List: host gateway + per-container cron ─────────────────────────────
+
+export function listOpenClawCronJobs(): OpenClawCronListResult {
+  const seen = new Set<string>();
+  const jobs: OpenClawCronJob[] = [];
+
+  // 1. Host gateway cron jobs
+  const hostJobs = listJobsOnHost();
+  if (hostJobs) {
+    for (const job of hostJobs) {
+      job.scheduleExpr = extractScheduleExpr(job);
+      job.source = 'host';
+      jobs.push(job);
+      if (job.id) seen.add(job.id);
+    }
+  }
+
+  // 2. Agent container cron jobs
+  const agents = discoverAgentContainers();
+  for (const agent of agents) {
+    const containerJobs = listJobsInContainer(agent.containerName);
+    if (containerJobs) {
+      for (const job of containerJobs) {
+        job.scheduleExpr = extractScheduleExpr(job);
+        job.source = 'container';
+        job.containerName = agent.containerName;
+        if (!job.agentId) job.agentId = agent.agentId;
+
+        if (job.id && seen.has(job.id)) continue;
+
+        jobs.push(job);
+        if (job.id) seen.add(job.id);
+      }
+    }
+  }
+
+  return { ok: true, jobs, total: jobs.length };
+}
+
+// ── Patch: try container first (if containerName given), then host ──────
+
+export interface CronPatchResult {
+  ok: boolean;
+  job?: OpenClawCronJob;
+  error?: string;
+}
+
+// ── Cron run history ─────────────────────────────────────────────────────
+
+export interface CronRunEntry {
+  ts?: number;
+  jobId?: string;
+  action?: string;
+  status?: string;
+  error?: string;
+  summary?: string;
+  runId?: string;
+  runAtMs?: number;
+  durationMs?: number;
+  nextRunAtMs?: number;
+  model?: string;
+  provider?: string;
+  usage?: Record<string, number>;
+  diagnostics?: {
+    summary?: string;
+    entries?: Array<{ ts?: number; source?: string; severity?: string; message?: string }>;
+  };
+  [key: string]: unknown;
+}
+
+export interface CronRunsResult {
+  ok: boolean;
+  entries: CronRunEntry[];
+  error?: string;
+}
+
+export function getCronRuns(
+  containerName: string,
+  jobId: string,
+  limit: number = 20,
+): CronRunsResult {
+  const gatewayUrls = [
+    'http://127.0.0.1:3000',
+    'http://127.0.0.1:18789',
+  ];
+
+  for (const gwUrl of gatewayUrls) {
+    try {
+      const raw = execFileSync('docker', [
+        'exec', '-e', `OPENCLAW_GATEWAY_URL=${gwUrl}`,
+        containerName, 'openclaw', 'cron', 'runs', '--id', jobId,
+        '--limit', String(limit),
+      ], { encoding: 'utf8', timeout: 15000 });
+
+      const parsed = JSON.parse(raw.trim()) as { entries?: CronRunEntry[] };
+      // Accept both empty and populated entries arrays
+      if (parsed && Array.isArray(parsed.entries)) {
+        return { ok: true, entries: parsed.entries };
+      }
+      // Not the expected format; try next port
+    } catch { /* try next gateway port */ }
+  }
+
+  return { ok: false, entries: [], error: 'Cannot connect to container gateway for runs' };
+}
+
+export function patchCronJob(id: string, patch: Partial<OpenClawCronJob>): CronPatchResult {
+  if (typeof patch.enabled !== 'boolean') {
+    return { ok: false, error: 'Only the enabled field can be patched' };
+  }
+
+  const containerName = (patch as any).containerName;
+
+  if (containerName) {
+    const ok = toggleInContainer(containerName, id, patch.enabled);
+    if (ok) return { ok: true, job: { id, enabled: patch.enabled } as OpenClawCronJob };
+    return { ok: false, error: `Failed to toggle cron in container ${containerName}` };
+  }
+
+  const ok = toggleOnHost(id, patch.enabled);
+  if (ok) return { ok: true, job: { id, enabled: patch.enabled } as OpenClawCronJob };
+  return { ok: false, error: 'Failed to toggle cron on host gateway' };
+}
+
+// ── Remove ─────────────────────────────────────────────────────────────
+
+export interface CronRemoveResult {
+  ok: boolean;
+  error?: string;
+}
+
+function removeOnHost(jobId: string): boolean {
+  try {
+    execFileSync('openclaw', ['cron', 'remove', jobId], {
+      encoding: 'utf8', timeout: 10000,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function removeInContainer(containerName: string, jobId: string): boolean {
+  const gatewayUrls = [
+    'http://127.0.0.1:3000',
+    'http://127.0.0.1:18789',
+  ];
+  for (const gwUrl of gatewayUrls) {
+    try {
+      execFileSync('docker', [
+        'exec', '-e', `OPENCLAW_GATEWAY_URL=${gwUrl}`,
+        containerName, 'openclaw', 'cron', 'remove', jobId,
+      ], { encoding: 'utf8', timeout: 10000 });
+      return true;
+    } catch { /* try next gateway port */ }
+  }
+  return false;
+}
+
+export function removeCronJob(id: string, containerName?: string): CronRemoveResult {
+  if (containerName) {
+    const ok = removeInContainer(containerName, id);
+    if (ok) return { ok: true };
+    return { ok: false, error: `Failed to remove cron job in container ${containerName}` };
+  }
+
+  const ok = removeOnHost(id);
+  if (ok) return { ok: true };
+  return { ok: false, error: 'Failed to remove cron job on host gateway' };
+}

package/lib/patterns/ApiAdapter.ts

@@ -0,0 +1,73 @@
+// Adapter pattern: normalizes raw API shapes into domain types
+import type { Session, SessionStatus, SessionEvent, Costs, ModelCost } from '../types';
+
+const VALID_STATUSES = new Set<SessionStatus>(['working', 'idle', 'error', 'active', 'completed']);
+
+function toStatus(raw: unknown): SessionStatus {
+  const s = String(raw ?? 'idle').toLowerCase();
+  return VALID_STATUSES.has(s as SessionStatus) ? (s as SessionStatus) : 'idle';
+}
+
+function toNumber(raw: unknown): number | null {
+  if (raw === null || raw === undefined) return null;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : null;
+}
+
+function toString(raw: unknown): string | null {
+  if (raw === null || raw === undefined) return null;
+  return String(raw);
+}
+
+/** Adapts a raw API session object into the canonical Session shape. */
+export function adaptSession(raw: Record<string, unknown>): Session {
+  return {
+    session_id: String(raw.session_id ?? raw.sessionId ?? raw.id ?? ''),
+    parent_id: toString(raw.parent_id ?? raw.parentId) ?? null,
+    label: toString(raw.label ?? raw.session_label) ?? null,
+    lineage_label: toString(raw.lineage_label ?? raw.lineageLabel ?? raw.agent_name) ?? null,
+    lineage_agent_name: toString(raw.lineage_agent_name ?? raw.agent_name) ?? null,
+    model: toString(raw.model) ?? null,
+    status: toStatus(raw.status),
+    tokens_in: toNumber(raw.tokens_in),
+    tokens_out: toNumber(raw.tokens_out),
+    cost_usd: toNumber(raw.cost_usd),
+    started_at: toNumber(raw.started_at),
+    updated_at: toNumber(raw.updated_at),
+    ended_at: toNumber(raw.ended_at),
+    task_preview: toString(raw.task_preview) ?? null,
+  };
+}
+
+/** Adapts a raw API event object. */
+export function adaptEvent(raw: Record<string, unknown>): SessionEvent {
+  return {
+    id: (raw.id as string | number | undefined) ?? undefined,
+    ts: toNumber(raw.ts) ?? undefined,
+    type: toString(raw.type ?? raw.event) ?? undefined,
+    event: toString(raw.event) ?? undefined,
+    data: raw.data,
+    session_id: toString(raw.session_id) ?? undefined,
+    session_label: toString(raw.session_label ?? raw.label) ?? undefined,
+  };
+}
+
+/** Adapts a raw costs API response. */
+export function adaptCosts(raw: Record<string, unknown>): Costs {
+  const byModel: ModelCost[] = Array.isArray(raw.byModel)
+    ? (raw.byModel as Record<string, unknown>[]).map((m) => ({
+        model: String(m.model ?? 'unknown'),
+        cost_usd: toNumber(m.cost_usd) ?? 0,
+        tokens_in: toNumber(m.tokens_in) ?? undefined,
+        tokens_out: toNumber(m.tokens_out) ?? undefined,
+        sessions: toNumber(m.sessions) ?? undefined,
+      }))
+    : [];
+
+  return {
+    today: toNumber(raw.today) ?? 0,
+    allTime: toNumber(raw.allTime) ?? 0,
+    allTimeSource: toString(raw.allTimeSource) ?? undefined,
+    byModel,
+  };
+}

package/lib/patterns/ApiClient.ts

@@ -0,0 +1,65 @@
+// Facade + Singleton: wraps all Rev4a API calls behind a clean interface
+import type { Session, SessionDetail, Costs, SessionEvent } from '../types';
+import { SessionFactory, EventFactory } from './SessionFactory';
+import { adaptCosts, adaptSession, adaptEvent } from './ApiAdapter';
+
+const API_TOKEN =
+  typeof process !== 'undefined'
+    ? (process.env.NEXT_PUBLIC_REV4A_TOKEN ?? '')
+    : '';
+
+async function apiFetch<T>(path: string, init?: RequestInit): Promise<T> {
+  const sep = path.includes('?') ? '&' : '?';
+  const url = `${path}${sep}token=${encodeURIComponent(API_TOKEN)}`;
+  const res = await fetch(url, {
+    ...init,
+    credentials: 'same-origin',
+    headers: { ...init?.headers },
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error((data as { error?: string }).error ?? `HTTP ${res.status}`);
+  return data as T;
+}
+
+class Rev4aApiClientClass {
+  private static _instance: Rev4aApiClientClass | null = null;
+
+  private constructor() {}
+
+  static get instance(): Rev4aApiClientClass {
+    Rev4aApiClientClass._instance ??= new Rev4aApiClientClass();
+    return Rev4aApiClientClass._instance;
+  }
+
+  async fetchSessions(): Promise<Session[]> {
+    const raw = await apiFetch<unknown[]>('/api/sessions');
+    return Array.isArray(raw) ? SessionFactory.createMany(raw) : [];
+  }
+
+  async fetchCosts(): Promise<Costs> {
+    const raw = await apiFetch<Record<string, unknown>>('/api/costs');
+    return adaptCosts(raw);
+  }
+
+  async fetchSessionDetail(id: string): Promise<SessionDetail> {
+    const raw = await apiFetch<Record<string, unknown>>(
+      `/api/session?id=${encodeURIComponent(id)}`,
+    );
+    return {
+      session: adaptSession((raw.session ?? raw) as Record<string, unknown>),
+      events: Array.isArray(raw.events)
+        ? EventFactory.createMany(raw.events as unknown[])
+        : [],
+      children: Array.isArray(raw.children)
+        ? SessionFactory.createMany(raw.children as unknown[])
+        : [],
+    };
+  }
+
+  async fetchEvents(limit = 50): Promise<SessionEvent[]> {
+    const raw = await apiFetch<unknown[]>(`/api/events?limit=${limit}`);
+    return Array.isArray(raw) ? EventFactory.createMany(raw) : [];
+  }
+}
+
+export const Rev4aApiClient = Rev4aApiClientClass.instance;

package/lib/patterns/EventBus.ts

@@ -0,0 +1,113 @@
+'use client';
+// Observer + Singleton: manages one shared SSE connection; components subscribe as observers
+
+import type { StreamMessage, Session, SessionEvent } from '../types';
+import { SessionFactory, EventFactory } from './SessionFactory';
+
+// ── Observer interface ─────────────────────────────────────────────────────
+
+export interface IDashboardObserver {
+  onSessions?(sessions: Session[]): void;
+  onEvents?(events: SessionEvent[]): void;
+  onCostUpdate?(today: number): void;
+}
+
+// ── Singleton EventBus ─────────────────────────────────────────────────────
+
+function sessionsFingerprint(data: unknown[]): string {
+  return (data as { session_id?: string; parent_id?: string | null; status?: string; cost_usd?: number; label?: string; lineage_label?: string | null }[])
+    .map((s) => `${s.session_id}|${s.parent_id ?? ''}|${s.status}|${s.cost_usd}|${s.label}|${s.lineage_label ?? ''}`)
+    .join('\n');
+}
+
+class Rev4aEventBusClass {
+  private static _instance: Rev4aEventBusClass | null = null;
+  private observers = new Set<IDashboardObserver>();
+  private source: EventSource | null = null;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private lastSessionsHash = '';
+  private latestSessions: Session[] | null = null;
+  private latestEvents: SessionEvent[] | null = null;
+  private latestCostToday: number | null = null;
+
+  private constructor() {}
+
+  static get instance(): Rev4aEventBusClass {
+    Rev4aEventBusClass._instance ??= new Rev4aEventBusClass();
+    return Rev4aEventBusClass._instance;
+  }
+
+  subscribe(observer: IDashboardObserver): () => void {
+    this.observers.add(observer);
+    this.replayTo(observer);
+    if (this.observers.size === 1) this.connect();
+    return () => this.unsubscribe(observer);
+  }
+
+  unsubscribe(observer: IDashboardObserver): void {
+    this.observers.delete(observer);
+    if (this.observers.size === 0) this.disconnect();
+  }
+
+  private connect(): void {
+    this.disconnect();
+    // EventSource cannot send headers; pass token via query param for browser auth
+    const token = process.env.NEXT_PUBLIC_REV4A_TOKEN ?? '';
+    this.source = new EventSource(`/api/stream?token=${encodeURIComponent(token)}`);
+
+    this.source.onmessage = (e: MessageEvent<string>) => {
+      try {
+        const msg = JSON.parse(e.data) as StreamMessage;
+        this.dispatch(msg);
+      } catch {
+        // Ignore malformed chunks.
+      }
+    };
+
+    this.source.onerror = () => {
+      this.source?.close();
+      this.source = null;
+      this.reconnectTimer = setTimeout(() => this.connect(), 5000);
+    };
+  }
+
+  private disconnect(): void {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.source?.close();
+    this.source = null;
+  }
+
+  private replayTo(observer: IDashboardObserver): void {
+    if (this.latestSessions && observer.onSessions) observer.onSessions(this.latestSessions);
+    if (this.latestEvents && observer.onEvents) observer.onEvents(this.latestEvents);
+    if (this.latestCostToday !== null && observer.onCostUpdate) observer.onCostUpdate(this.latestCostToday);
+  }
+
+  private dispatch(msg: StreamMessage): void {
+    if (msg.type === 'sessions') {
+      const hash = sessionsFingerprint(Array.isArray(msg.data) ? msg.data : []);
+      if (hash === this.lastSessionsHash) return;
+      this.lastSessionsHash = hash;
+      this.latestSessions = SessionFactory.createMany(msg.data);
+    } else if (msg.type === 'events') {
+      this.latestEvents = EventFactory.createMany(msg.data);
+    } else if (msg.type === 'costs') {
+      this.latestCostToday = Number(msg.data?.today ?? 0);
+    }
+
+    for (const obs of this.observers) {
+      if (msg.type === 'sessions' && obs.onSessions && this.latestSessions) {
+        obs.onSessions(this.latestSessions);
+      } else if (msg.type === 'events' && obs.onEvents && this.latestEvents) {
+        obs.onEvents(this.latestEvents);
+      } else if (msg.type === 'costs' && obs.onCostUpdate && this.latestCostToday !== null) {
+        obs.onCostUpdate(this.latestCostToday);
+      }
+    }
+  }
+}
+
+export const Rev4aEventBus = Rev4aEventBusClass.instance;

package/lib/patterns/FilterStrategy.ts

@@ -0,0 +1,79 @@
+// Strategy pattern: interchangeable session filter algorithms
+import type { Session, FilterConfig, Period, PERIOD_MS } from '../types';
+import { PERIOD_MS as PERIOD_MS_MAP } from '../types';
+import { extractAgentId, isCronSession } from './SessionFactory';
+import { isSessionActive } from './sessionPresentation';
+
+/** Base interface — every filter strategy must implement this. */
+export interface IFilterStrategy {
+  filter(sessions: Session[]): Session[];
+}
+
+// ── Concrete strategies ────────────────────────────────────────────────────
+
+export class AgentFilterStrategy implements IFilterStrategy {
+  constructor(private readonly agent: string) {}
+
+  filter(sessions: Session[]): Session[] {
+    if (this.agent === 'all') return sessions;
+    return sessions.filter((s) => extractAgentId(s.session_id) === this.agent);
+  }
+}
+
+export class ActiveOnlyFilterStrategy implements IFilterStrategy {
+  filter(sessions: Session[]): Session[] {
+    return sessions.filter((s) => isSessionActive(s) && s.status !== 'idle');
+  }
+}
+
+export class NoCronFilterStrategy implements IFilterStrategy {
+  filter(sessions: Session[]): Session[] {
+    return sessions.filter((s) => !isCronSession(s.session_id));
+  }
+}
+
+export class PeriodFilterStrategy implements IFilterStrategy {
+  private readonly cutoff: number;
+
+  constructor(period: Period) {
+    this.cutoff =
+      period === 'all' ? 0 : Date.now() - PERIOD_MS_MAP[period as Exclude<Period, 'all'>];
+  }
+
+  filter(sessions: Session[]): Session[] {
+    if (this.cutoff === 0) return sessions;
+    return sessions.filter((s) => {
+      const latest = Math.max(Number(s.started_at ?? 0), Number(s.updated_at ?? 0));
+      return latest >= this.cutoff;
+    });
+  }
+}
+
+// ── Composite strategy ─────────────────────────────────────────────────────
+
+/** Chains multiple strategies, applying each in sequence. */
+export class CompositeFilterStrategy implements IFilterStrategy {
+  private readonly strategies: IFilterStrategy[];
+
+  constructor(strategies: IFilterStrategy[]) {
+    this.strategies = strategies;
+  }
+
+  filter(sessions: Session[]): Session[] {
+    return this.strategies.reduce((acc, s) => s.filter(acc), sessions);
+  }
+}
+
+// ── Factory for building the composite from a FilterConfig ────────────────
+
+export function buildFilterStrategy(config: FilterConfig): IFilterStrategy {
+  const strategies: IFilterStrategy[] = [
+    new AgentFilterStrategy(config.agent),
+    new PeriodFilterStrategy(config.period),
+  ];
+
+  if (config.showOnlyActive) strategies.push(new ActiveOnlyFilterStrategy());
+  if (!config.showCron) strategies.push(new NoCronFilterStrategy());
+
+  return new CompositeFilterStrategy(strategies);
+}