@phronesis-io/openclaw-eigenflux 0.0.1 → 0.0.3

package/src/pm-polling-client.test.ts

@@ -1,390 +0,0 @@
-import { EigenFluxPmPollingClient } from './pm-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('EigenFluxPmPollingClient', () => {
-  const originalFetch = global.fetch;
-
-  afterEach(() => {
-    global.fetch = originalFetch;
-    jest.restoreAllMocks();
-  });
-
-  test('polls PM and forwards the full payload to callback', async () => {
-    const onPmFetched = jest.fn().mockResolvedValue(undefined);
-    const onAuthRequired = jest.fn().mockResolvedValue(undefined);
-
-    global.fetch = jest.fn().mockResolvedValue(
-      new Response(
-        JSON.stringify({
-          code: 0,
-          msg: 'success',
-          data: {
-            messages: [
-              {
-                message_id: 'msg-101',
-                from_agent_id: 'agent-42',
-                conversation_id: 'conv-1',
-                content: 'Hello from agent',
-                created_at: 1760000000000,
-              },
-            ],
-          },
-        }),
-        {
-          status: 200,
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        }
-      )
-    ) as typeof fetch;
-
-    const client = new EigenFluxPmPollingClient({
-      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(),
-      onPmFetched,
-      onAuthRequired,
-    });
-
-    const result = await client.pollOnce();
-
-    expect(result).toEqual(
-      expect.objectContaining({
-        kind: 'success',
-      })
-    );
-    expect(onPmFetched).toHaveBeenCalledWith(
-      expect.objectContaining({
-        code: 0,
-        data: expect.objectContaining({
-          messages: [
-            expect.objectContaining({
-              message_id: 'msg-101',
-              content: 'Hello from agent',
-            }),
-          ],
-        }),
-      })
-    );
-    expect(onAuthRequired).not.toHaveBeenCalled();
-  });
-
-  test('does not invoke callback when messages array is empty', async () => {
-    const onPmFetched = jest.fn().mockResolvedValue(undefined);
-    const onAuthRequired = jest.fn().mockResolvedValue(undefined);
-
-    global.fetch = jest.fn().mockResolvedValue(
-      new Response(
-        JSON.stringify({
-          code: 0,
-          msg: 'success',
-          data: { messages: [] },
-        }),
-        { status: 200, headers: { 'Content-Type': 'application/json' } }
-      )
-    ) as typeof fetch;
-
-    const client = new EigenFluxPmPollingClient({
-      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(),
-      onPmFetched,
-      onAuthRequired,
-    });
-
-    const result = await client.pollOnce();
-
-    expect(result.kind).toBe('success');
-    expect(onPmFetched).not.toHaveBeenCalled();
-    expect(onAuthRequired).not.toHaveBeenCalled();
-  });
-
-  test('emits auth-required callback when token is missing', async () => {
-    const onPmFetched = jest.fn().mockResolvedValue(undefined);
-    const onAuthRequired = jest.fn().mockResolvedValue(undefined);
-
-    const client = new EigenFluxPmPollingClient({
-      apiUrl: 'http://127.0.0.1:8080',
-      getAuthState: () => ({
-        status: 'missing',
-        credentialsPath: '/tmp/eigenflux/credentials.json',
-      }),
-      pollIntervalSec: 60,
-      logger: createLogger(),
-      onPmFetched,
-      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(onPmFetched).not.toHaveBeenCalled();
-    expect(global.fetch).toBe(originalFetch);
-  });
-
-  test('emits auth-required callback when token is expired', async () => {
-    const onPmFetched = jest.fn().mockResolvedValue(undefined);
-    const onAuthRequired = jest.fn().mockResolvedValue(undefined);
-
-    const client = new EigenFluxPmPollingClient({
-      apiUrl: 'http://127.0.0.1:8080',
-      getAuthState: () => ({
-        status: 'expired',
-        credentialsPath: '/tmp/eigenflux/credentials.json',
-        source: 'file',
-        expiresAt: 1700000000000,
-      }),
-      pollIntervalSec: 60,
-      logger: createLogger(),
-      onPmFetched,
-      onAuthRequired,
-    });
-
-    const result = await client.pollOnce();
-
-    expect(result).toEqual({
-      kind: 'auth_required',
-      authEvent: {
-        reason: 'expired_token',
-        credentialsPath: '/tmp/eigenflux/credentials.json',
-        source: 'file',
-        expiresAt: 1700000000000,
-      },
-    });
-    expect(onAuthRequired).toHaveBeenCalledWith({
-      reason: 'expired_token',
-      credentialsPath: '/tmp/eigenflux/credentials.json',
-      source: 'file',
-      expiresAt: 1700000000000,
-    });
-    expect(onPmFetched).not.toHaveBeenCalled();
-  });
-
-  test('emits auth-required callback when PM fetch returns 401', async () => {
-    const onPmFetched = 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 EigenFluxPmPollingClient({
-      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(),
-      onPmFetched,
-      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(onPmFetched).not.toHaveBeenCalled();
-  });
-
-  test('sends User-Agent header with plugin version', async () => {
-    const onPmFetched = jest.fn().mockResolvedValue(undefined);
-    const onAuthRequired = jest.fn().mockResolvedValue(undefined);
-
-    global.fetch = jest.fn().mockResolvedValue(
-      new Response(
-        JSON.stringify({
-          code: 0,
-          msg: 'success',
-          data: { messages: [] },
-        }),
-        { status: 200, headers: { 'Content-Type': 'application/json' } }
-      )
-    ) as typeof fetch;
-
-    const client = new EigenFluxPmPollingClient({
-      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(),
-      onPmFetched,
-      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 EigenFluxPmPollingClient({
-      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),
-      onPmFetched: 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 PM (url=http://127.0.0.1:8080/api/v1/pm/fetch): 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')
-    );
-  });
-
-  test('start and stop lifecycle', async () => {
-    const loggerSpies = createLoggerSpies();
-
-    global.fetch = jest.fn().mockResolvedValue(
-      new Response(
-        JSON.stringify({
-          code: 0,
-          msg: 'success',
-          data: { messages: [] },
-        }),
-        { status: 200, headers: { 'Content-Type': 'application/json' } }
-      )
-    ) as typeof fetch;
-
-    const client = new EigenFluxPmPollingClient({
-      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),
-      onPmFetched: jest.fn().mockResolvedValue(undefined),
-      onAuthRequired: jest.fn().mockResolvedValue(undefined),
-    });
-
-    await client.start();
-
-    expect(loggerSpies.info).toHaveBeenCalledWith(
-      expect.stringContaining('Starting PM polling client')
-    );
-    // Initial poll should have fired
-    expect(global.fetch).toHaveBeenCalledTimes(1);
-
-    // Starting again should warn
-    await client.start();
-    expect(loggerSpies.warn).toHaveBeenCalledWith(
-      expect.stringContaining('PM polling client already running')
-    );
-
-    client.stop();
-    expect(loggerSpies.info).toHaveBeenCalledWith(
-      expect.stringContaining('Stopping PM polling client')
-    );
-
-    // Stopping again should be a no-op
-    client.stop();
-  });
-});

package/src/pm-polling-client.ts

@@ -1,257 +0,0 @@
-/**
- * Polling client for EigenFlux private message updates
- */
-
-import { AuthState } from './credentials-loader';
-import { PLUGIN_CONFIG } from './config';
-import { Logger } from './logger';
-import { AuthRequiredEvent, PollOnceOptions } from './polling-client';
-
-export interface PmMessage {
-  message_id: string;
-  from_agent_id: string;
-  conversation_id: string;
-  content: string;
-  created_at: number;
-}
-
-export interface PmFetchResponse {
-  code: number;
-  msg: string;
-  data: {
-    messages: PmMessage[];
-  };
-}
-
-export interface PmPollingClientConfig {
-  apiUrl: string;
-  getAuthState: () => AuthState;
-  pollIntervalSec: number;
-  logger: Logger;
-  onPmFetched: (payload: PmFetchResponse) => Promise<void>;
-  onAuthRequired: (event: AuthRequiredEvent) => Promise<void>;
-}
-
-export type PmPollResult =
-  | {
-      kind: 'success';
-      payload: PmFetchResponse;
-    }
-  | {
-      kind: 'auth_required';
-      authEvent: AuthRequiredEvent;
-    }
-  | {
-      kind: 'error';
-      error: Error;
-    };
-
-export class EigenFluxPmPollingClient {
-  private config: PmPollingClientConfig;
-  private intervalId: NodeJS.Timeout | null = null;
-  private isRunning = false;
-
-  constructor(config: PmPollingClientConfig) {
-    this.config = config;
-  }
-
-  async start(): Promise<void> {
-    if (this.isRunning) {
-      this.config.logger.warn('PM polling client already running');
-      return;
-    }
-
-    this.isRunning = true;
-    this.config.logger.info(
-      `Starting PM 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(`PM polling error: ${this.formatError(err)}`);
-      });
-    }, this.config.pollIntervalSec * 1000);
-  }
-
-  stop(): void {
-    if (!this.isRunning) {
-      return;
-    }
-
-    this.config.logger.info('Stopping PM polling client');
-    this.isRunning = false;
-
-    if (this.intervalId) {
-      clearInterval(this.intervalId);
-      this.intervalId = null;
-    }
-  }
-
-  async pollOnce(options: PollOnceOptions = {}): Promise<PmPollResult> {
-    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 PM 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/pm/fetch`;
-
-    try {
-      this.config.logger.info(`Polling PM 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 PmFetchResponse;
-
-      if (data.code !== 0) {
-        throw new Error(`API error: ${data.msg}`);
-      }
-
-      const messages = data.data.messages ?? [];
-      this.config.logger.info(
-        `Polled PM: ${messages.length} messages`
-      );
-
-      if (notifyFeed && messages.length > 0) {
-        await this.config.onPmFetched(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 PM (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;
-  }
-}