@phronesis-io/openclaw-eigenflux 0.0.1 → 0.0.3

package/src/polling-client.test.ts

@@ -1,279 +0,0 @@
-import { EigenFluxPollingClient } from './polling-client';
-import { Logger } from './logger';
-
-function createLoggerSpies() {
-  return {
-    info: jest.fn(),
-    warn: jest.fn(),
-    error: jest.fn(),
-    debug: jest.fn(),
-  };
-}
-
-function createLogger(spies = createLoggerSpies()): Logger {
-  return new Logger(spies);
-}
-
-describe('EigenFluxPollingClient', () => {
-  const originalFetch = global.fetch;
-
-  afterEach(() => {
-    global.fetch = originalFetch;
-    jest.restoreAllMocks();
-  });
-
-  test('polls feed and forwards the full payload to callback', async () => {
-    const onFeedPolled = jest.fn().mockResolvedValue(undefined);
-    const onAuthRequired = jest.fn().mockResolvedValue(undefined);
-
-    global.fetch = jest.fn().mockResolvedValue(
-      new Response(
-        JSON.stringify({
-          code: 0,
-          msg: 'success',
-          data: {
-            items: [
-              {
-                item_id: 'item-101',
-                group_id: 'group-101',
-                summary: 'Important signal',
-                broadcast_type: 'info',
-                updated_at: 1760000000000,
-              },
-            ],
-            has_more: false,
-            notifications: [
-              {
-                notification_id: 'notif-1',
-                type: 'system',
-                content: 'Feed refreshed successfully',
-                created_at: 1760000000100,
-              },
-            ],
-          },
-        }),
-        {
-          status: 200,
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        }
-      )
-    ) as typeof fetch;
-
-    const client = new EigenFluxPollingClient({
-      apiUrl: 'http://127.0.0.1:8080',
-      getAuthState: () => ({
-        status: 'available',
-        accessToken: 'at_test_token',
-        source: 'file',
-        credentialsPath: '/tmp/eigenflux/credentials.json',
-      }),
-      pollIntervalSec: 60,
-      logger: createLogger(),
-      onFeedPolled,
-      onAuthRequired,
-    });
-
-    const result = await client.pollOnce();
-
-    expect(result).toEqual(
-      expect.objectContaining({
-        kind: 'success',
-      })
-    );
-    expect(onFeedPolled).toHaveBeenCalledWith(
-      expect.objectContaining({
-        code: 0,
-        data: expect.objectContaining({
-          items: [
-            expect.objectContaining({
-              item_id: 'item-101',
-              summary: 'Important signal',
-            }),
-          ],
-          notifications: [
-            expect.objectContaining({
-              notification_id: 'notif-1',
-            }),
-          ],
-        }),
-      })
-    );
-    expect(onAuthRequired).not.toHaveBeenCalled();
-  });
-
-  test('emits auth-required callback when token is missing', async () => {
-    const onFeedPolled = jest.fn().mockResolvedValue(undefined);
-    const onAuthRequired = jest.fn().mockResolvedValue(undefined);
-
-    const client = new EigenFluxPollingClient({
-      apiUrl: 'http://127.0.0.1:8080',
-      getAuthState: () => ({
-        status: 'missing',
-        credentialsPath: '/tmp/eigenflux/credentials.json',
-      }),
-      pollIntervalSec: 60,
-      logger: createLogger(),
-      onFeedPolled,
-      onAuthRequired,
-    });
-
-    const result = await client.pollOnce();
-
-    expect(result).toEqual({
-      kind: 'auth_required',
-      authEvent: {
-        reason: 'missing_token',
-        credentialsPath: '/tmp/eigenflux/credentials.json',
-        source: undefined,
-        expiresAt: undefined,
-      },
-    });
-    expect(onAuthRequired).toHaveBeenCalledWith({
-      reason: 'missing_token',
-      credentialsPath: '/tmp/eigenflux/credentials.json',
-      source: undefined,
-      expiresAt: undefined,
-    });
-    expect(onFeedPolled).not.toHaveBeenCalled();
-    expect(global.fetch).toBe(originalFetch);
-  });
-
-  test('emits auth-required callback when feed returns 401', async () => {
-    const onFeedPolled = jest.fn().mockResolvedValue(undefined);
-    const onAuthRequired = jest.fn().mockResolvedValue(undefined);
-
-    global.fetch = jest.fn().mockResolvedValue(
-      new Response('', {
-        status: 401,
-        statusText: 'Unauthorized',
-      })
-    ) as typeof fetch;
-
-    const client = new EigenFluxPollingClient({
-      apiUrl: 'http://127.0.0.1:8080',
-      getAuthState: () => ({
-        status: 'available',
-        accessToken: 'at_test_token',
-        source: 'file',
-        credentialsPath: '/tmp/eigenflux/credentials.json',
-      }),
-      pollIntervalSec: 60,
-      logger: createLogger(),
-      onFeedPolled,
-      onAuthRequired,
-    });
-
-    const result = await client.pollOnce();
-
-    expect(result).toEqual({
-      kind: 'auth_required',
-      authEvent: {
-        reason: 'unauthorized',
-        credentialsPath: '/tmp/eigenflux/credentials.json',
-        source: 'file',
-        expiresAt: undefined,
-        statusCode: 401,
-      },
-    });
-    expect(onAuthRequired).toHaveBeenCalledWith({
-      reason: 'unauthorized',
-      credentialsPath: '/tmp/eigenflux/credentials.json',
-      source: 'file',
-      expiresAt: undefined,
-      statusCode: 401,
-    });
-    expect(onFeedPolled).not.toHaveBeenCalled();
-  });
-
-  test('sends User-Agent header with plugin version', async () => {
-    const onFeedPolled = jest.fn().mockResolvedValue(undefined);
-    const onAuthRequired = jest.fn().mockResolvedValue(undefined);
-
-    global.fetch = jest.fn().mockResolvedValue(
-      new Response(
-        JSON.stringify({
-          code: 0,
-          msg: 'success',
-          data: { items: [], has_more: false, notifications: [] },
-        }),
-        { status: 200, headers: { 'Content-Type': 'application/json' } }
-      )
-    ) as typeof fetch;
-
-    const client = new EigenFluxPollingClient({
-      apiUrl: 'http://127.0.0.1:8080',
-      getAuthState: () => ({
-        status: 'available',
-        accessToken: 'at_test_token',
-        source: 'file',
-        credentialsPath: '/tmp/eigenflux/credentials.json',
-      }),
-      pollIntervalSec: 60,
-      logger: createLogger(),
-      onFeedPolled,
-      onAuthRequired,
-    });
-
-    await client.pollOnce();
-
-    const fetchCall = (global.fetch as jest.Mock).mock.calls[0];
-    const headers = fetchCall[1].headers;
-    expect(headers['User-Agent']).toContain('eigenflux-plugin');
-    expect(headers['User-Agent']).toContain('node/');
-  });
-
-  test('logs detailed fetch failure diagnostics', async () => {
-    const loggerSpies = createLoggerSpies();
-    const networkCause = Object.assign(
-      new Error('connect ECONNREFUSED 127.0.0.1:8080'),
-      {
-        code: 'ECONNREFUSED',
-        errno: -61,
-        syscall: 'connect',
-        address: '127.0.0.1',
-        port: 8080,
-      }
-    );
-
-    global.fetch = jest.fn().mockRejectedValue(
-      Object.assign(new TypeError('fetch failed'), { cause: networkCause })
-    ) as typeof fetch;
-
-    const client = new EigenFluxPollingClient({
-      apiUrl: 'http://127.0.0.1:8080',
-      getAuthState: () => ({
-        status: 'available',
-        accessToken: 'at_test_token',
-        source: 'file',
-        credentialsPath: '/tmp/eigenflux/credentials.json',
-      }),
-      pollIntervalSec: 60,
-      logger: createLogger(loggerSpies),
-      onFeedPolled: jest.fn().mockResolvedValue(undefined),
-      onAuthRequired: jest.fn().mockResolvedValue(undefined),
-    });
-
-    const result = await client.pollOnce();
-
-    expect(result.kind).toBe('error');
-    expect(loggerSpies.error).toHaveBeenCalledWith(
-      expect.stringContaining(
-        '[EigenFlux] Failed to poll feed (url=http://127.0.0.1:8080/api/v1/items/feed?action=refresh&limit=20): TypeError: fetch failed'
-      )
-    );
-    expect(loggerSpies.error).toHaveBeenCalledWith(
-      expect.stringContaining('cause=Error: connect ECONNREFUSED 127.0.0.1:8080')
-    );
-    expect(loggerSpies.error).toHaveBeenCalledWith(
-      expect.stringContaining('code=ECONNREFUSED')
-    );
-    expect(loggerSpies.error).toHaveBeenCalledWith(
-      expect.stringContaining('address=127.0.0.1')
-    );
-    expect(loggerSpies.error).toHaveBeenCalledWith(
-      expect.stringContaining('port=8080')
-    );
-  });
-});

package/src/polling-client.ts

@@ -1,283 +0,0 @@
-/**
- * Polling client for EigenFlux feed updates
- */
-
-import { AuthState } from './credentials-loader';
-import { PLUGIN_CONFIG } from './config';
-import { Logger } from './logger';
-
-export interface FeedItem {
-  item_id: string;
-  summary?: string;
-  broadcast_type: string;
-  domains?: string[];
-  keywords?: string[];
-  group_id?: string;
-  source_type?: string;
-  url?: string;
-  updated_at: number;
-}
-
-export interface FeedNotification {
-  notification_id: string;
-  type: string;
-  content: string;
-  created_at: number;
-}
-
-export interface FeedResponse {
-  code: number;
-  msg: string;
-  data: {
-    items: FeedItem[];
-    has_more: boolean;
-    notifications: FeedNotification[];
-  };
-}
-
-export interface PollingClientConfig {
-  apiUrl: string;
-  getAuthState: () => AuthState;
-  pollIntervalSec: number;
-  logger: Logger;
-  onFeedPolled: (payload: FeedResponse) => Promise<void>;
-  onAuthRequired: (event: AuthRequiredEvent) => Promise<void>;
-}
-
-export interface AuthRequiredEvent {
-  reason: 'missing_token' | 'expired_token' | 'unauthorized';
-  credentialsPath: string;
-  source?: 'file';
-  expiresAt?: number;
-  statusCode?: number;
-}
-
-export type PollResult =
-  | {
-      kind: 'success';
-      payload: FeedResponse;
-    }
-  | {
-      kind: 'auth_required';
-      authEvent: AuthRequiredEvent;
-    }
-  | {
-      kind: 'error';
-      error: Error;
-    };
-
-export interface PollOnceOptions {
-  notifyFeed?: boolean;
-  notifyAuthRequired?: boolean;
-}
-
-export class EigenFluxPollingClient {
-  private config: PollingClientConfig;
-  private intervalId: NodeJS.Timeout | null = null;
-  private isRunning = false;
-
-  constructor(config: PollingClientConfig) {
-    this.config = config;
-  }
-
-  async start(): Promise<void> {
-    if (this.isRunning) {
-      this.config.logger.warn('Polling client already running');
-      return;
-    }
-
-    this.isRunning = true;
-    this.config.logger.info(
-      `Starting polling client (interval: ${this.config.pollIntervalSec}s)`
-    );
-
-    // Initial fetch
-    await this.pollOnce();
-
-    // Schedule periodic polling
-    this.intervalId = setInterval(() => {
-      this.pollOnce().catch((err) => {
-        this.config.logger.error(`Polling error: ${this.formatError(err)}`);
-      });
-    }, this.config.pollIntervalSec * 1000);
-  }
-
-  stop(): void {
-    if (!this.isRunning) {
-      return;
-    }
-
-    this.config.logger.info('Stopping polling client');
-    this.isRunning = false;
-
-    if (this.intervalId) {
-      clearInterval(this.intervalId);
-      this.intervalId = null;
-    }
-  }
-
-  async pollOnce(options: PollOnceOptions = {}): Promise<PollResult> {
-    const notifyFeed = options.notifyFeed ?? true;
-    const notifyAuthRequired = options.notifyAuthRequired ?? true;
-    const authState = this.config.getAuthState();
-    if (authState.status !== 'available') {
-      this.config.logger.warn(
-        `No usable access token available (status=${authState.status}), skipping poll`
-      );
-      const authEvent: AuthRequiredEvent = {
-        reason: authState.status === 'expired' ? 'expired_token' : 'missing_token',
-        credentialsPath: authState.credentialsPath,
-        source: authState.source,
-        expiresAt: authState.expiresAt,
-      };
-      if (notifyAuthRequired) {
-        await this.config.onAuthRequired(authEvent);
-      }
-      return {
-        kind: 'auth_required',
-        authEvent,
-      };
-    }
-
-    const url = `${this.config.apiUrl}/api/v1/items/feed?action=refresh&limit=20`;
-
-    try {
-      this.config.logger.info(`Polling feed request: ${url}`);
-      this.config.logger.debug(`Polling: ${url}`);
-
-      const response = await fetch(url, {
-        method: 'GET',
-        headers: {
-          Authorization: `Bearer ${authState.accessToken}`,
-          'Content-Type': 'application/json',
-          'User-Agent': PLUGIN_CONFIG.USER_AGENT,
-        },
-      });
-
-      if (response.status === 401) {
-        const authEvent: AuthRequiredEvent = {
-          reason: 'unauthorized',
-          credentialsPath: authState.credentialsPath,
-          source: authState.source,
-          expiresAt: authState.expiresAt,
-          statusCode: 401,
-        };
-        if (notifyAuthRequired) {
-          await this.config.onAuthRequired(authEvent);
-        }
-        return {
-          kind: 'auth_required',
-          authEvent,
-        };
-      }
-
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-      }
-
-      const data = (await response.json()) as FeedResponse;
-
-      if (data.code !== 0) {
-        throw new Error(`API error: ${data.msg}`);
-      }
-
-      const items = data.data.items ?? [];
-      const notifications = data.data.notifications ?? [];
-      this.config.logger.info(
-        `Polled feed: ${items.length} items, notifications=${notifications.length}, has_more=${data.data.has_more}`
-      );
-
-      if (notifyFeed && (items.length > 0 || notifications.length > 0)) {
-        await this.config.onFeedPolled(data);
-      }
-      return {
-        kind: 'success',
-        payload: data,
-      };
-    } catch (error) {
-      const normalized = error instanceof Error ? error : new Error(String(error));
-      this.config.logger.error(
-        `Failed to poll feed (url=${url}): ${this.formatError(normalized)}`
-      );
-      return {
-        kind: 'error',
-        error: normalized,
-      };
-    }
-  }
-
-  private formatError(error: unknown): string {
-    const segments: string[] = [];
-    this.appendErrorSegment(segments, error, false);
-    return segments.join(' | ');
-  }
-
-  private appendErrorSegment(segments: string[], error: unknown, isCause: boolean): void {
-    const prefix = isCause ? 'cause=' : '';
-
-    if (error instanceof Error) {
-      const details: string[] = [`${error.name}: ${error.message}`];
-      const metadata = this.errorMetadata(error);
-      if (metadata.length > 0) {
-        details.push(...metadata);
-      }
-      segments.push(prefix + details.join(' | '));
-
-      const cause = (error as Error & { cause?: unknown }).cause;
-      if (cause !== undefined) {
-        this.appendErrorSegment(segments, cause, true);
-      }
-      return;
-    }
-
-    if (error && typeof error === 'object') {
-      const metadata = this.errorMetadata(error);
-      if (metadata.length > 0) {
-        segments.push(prefix + metadata.join(' | '));
-        return;
-      }
-    }
-
-    segments.push(prefix + String(error));
-  }
-
-  private errorMetadata(value: unknown): string[] {
-    if (!value || typeof value !== 'object') {
-      return [];
-    }
-
-    const record = value as {
-      code?: unknown;
-      errno?: unknown;
-      syscall?: unknown;
-      address?: unknown;
-      port?: unknown;
-      status?: unknown;
-      statusText?: unknown;
-    };
-
-    const metadata: string[] = [];
-    if (record.code !== undefined) {
-      metadata.push(`code=${String(record.code)}`);
-    }
-    if (record.errno !== undefined) {
-      metadata.push(`errno=${String(record.errno)}`);
-    }
-    if (record.syscall !== undefined) {
-      metadata.push(`syscall=${String(record.syscall)}`);
-    }
-    if (record.address !== undefined) {
-      metadata.push(`address=${String(record.address)}`);
-    }
-    if (record.port !== undefined) {
-      metadata.push(`port=${String(record.port)}`);
-    }
-    if (record.status !== undefined) {
-      metadata.push(`status=${String(record.status)}`);
-    }
-    if (record.statusText !== undefined) {
-      metadata.push(`status_text=${String(record.statusText)}`);
-    }
-    return metadata;
-  }
-}

package/src/session-route-memory.ts

@@ -1,106 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { Logger } from './logger';
-
-export type StoredNotificationRoute = {
-  sessionKey: string;
-  agentId: string;
-  replyChannel?: string;
-  replyTo?: string;
-  replyAccountId?: string;
-  updatedAt: number;
-};
-
-function readNonEmptyString(value: unknown): string | undefined {
-  if (typeof value !== 'string') {
-    return undefined;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function normalizeChannel(value: unknown): string | undefined {
-  return readNonEmptyString(value)?.toLowerCase();
-}
-
-export function resolveSessionRouteMemoryPath(workdir: string): string {
-  return path.join(workdir, 'session.json');
-}
-
-export function readStoredNotificationRoute(
-  workdir: string | undefined,
-  logger: Logger
-): StoredNotificationRoute | undefined {
-  const trimmedWorkdir = readNonEmptyString(workdir);
-  if (!trimmedWorkdir) {
-    return undefined;
-  }
-
-  const filePath = resolveSessionRouteMemoryPath(trimmedWorkdir);
-  try {
-    if (!fs.existsSync(filePath)) {
-      return undefined;
-    }
-
-    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as unknown;
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-      return undefined;
-    }
-
-    const record = parsed as Record<string, unknown>;
-    const sessionKey = readNonEmptyString(record.sessionKey);
-    const agentId = readNonEmptyString(record.agentId);
-    if (!sessionKey || !agentId) {
-      return undefined;
-    }
-
-    return {
-      sessionKey,
-      agentId,
-      replyChannel: normalizeChannel(record.replyChannel),
-      replyTo: readNonEmptyString(record.replyTo),
-      replyAccountId: readNonEmptyString(record.replyAccountId),
-      updatedAt:
-        typeof record.updatedAt === 'number' && Number.isFinite(record.updatedAt)
-          ? record.updatedAt
-          : 0,
-    };
-  } catch (error) {
-    logger.debug(
-      `Failed to read remembered session route ${filePath}: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return undefined;
-  }
-}
-
-export function writeStoredNotificationRoute(
-  workdir: string | undefined,
-  route: Omit<StoredNotificationRoute, 'updatedAt'>,
-  logger: Logger
-): boolean {
-  const trimmedWorkdir = readNonEmptyString(workdir);
-  if (!trimmedWorkdir) {
-    return false;
-  }
-
-  const filePath = resolveSessionRouteMemoryPath(trimmedWorkdir);
-  const payload: StoredNotificationRoute = {
-    sessionKey: route.sessionKey,
-    agentId: route.agentId,
-    replyChannel: normalizeChannel(route.replyChannel),
-    replyTo: readNonEmptyString(route.replyTo),
-    replyAccountId: readNonEmptyString(route.replyAccountId),
-    updatedAt: Date.now(),
-  };
-
-  try {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`, 'utf-8');
-    return true;
-  } catch (error) {
-    logger.warn(
-      `Failed to write remembered session route ${filePath}: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return false;
-  }
-}