@phronesis-io/openclaw-eigenflux 0.0.1 → 0.0.3

package/src/credentials-loader.test.ts

@@ -1,78 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-
-import { CredentialsLoader } from './credentials-loader';
-import { Logger } from './logger';
-
-function createLogger(): Logger {
-  return new Logger({
-    info: jest.fn(),
-    warn: jest.fn(),
-    error: jest.fn(),
-    debug: jest.fn(),
-  });
-}
-
-describe('CredentialsLoader', () => {
-  let workdir: string;
-
-  beforeEach(() => {
-    workdir = fs.mkdtempSync(path.join(os.tmpdir(), 'eigenflux-workdir-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(workdir, { recursive: true, force: true });
-  });
-
-  test('loads access token from credentials.json', () => {
-    fs.writeFileSync(
-      path.join(workdir, 'credentials.json'),
-      JSON.stringify({ access_token: 'at_file_token' }),
-      'utf-8'
-    );
-
-    const loader = new CredentialsLoader(createLogger(), workdir);
-    expect(loader.loadAccessToken()).toBe('at_file_token');
-  });
-
-  test('returns null when credentials file is missing', () => {
-    const loader = new CredentialsLoader(createLogger(), workdir);
-    expect(loader.loadAccessToken()).toBeNull();
-  });
-
-  test('returns expired auth state when credentials file token is stale', () => {
-    fs.writeFileSync(
-      path.join(workdir, 'credentials.json'),
-      JSON.stringify({
-        access_token: 'at_expired_token',
-        expires_at: Date.now() - 1_000,
-      }),
-      'utf-8'
-    );
-
-    const loader = new CredentialsLoader(createLogger(), workdir);
-    expect(loader.loadAuthState()).toEqual(
-      expect.objectContaining({
-        status: 'expired',
-        source: 'file',
-      })
-    );
-    expect(loader.loadAccessToken()).toBeNull();
-  });
-
-  test('saveAccessToken creates the workdir and writes credentials.json', () => {
-    const nestedWorkdir = path.join(workdir, 'nested/eigenflux');
-    const loader = new CredentialsLoader(createLogger(), nestedWorkdir);
-
-    loader.saveAccessToken('at_saved_token', 'bot@example.com', 1_760_000_000_000);
-
-    const credentialsPath = path.join(nestedWorkdir, 'credentials.json');
-    expect(fs.existsSync(credentialsPath)).toBe(true);
-    expect(JSON.parse(fs.readFileSync(credentialsPath, 'utf-8'))).toEqual({
-      access_token: 'at_saved_token',
-      email: 'bot@example.com',
-      expires_at: 1_760_000_000_000,
-    });
-  });
-});

package/src/credentials-loader.ts

@@ -1,121 +0,0 @@
-/**
- * Credentials loader for the EigenFlux auth token.
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { Logger } from './logger';
-import { PLUGIN_CONFIG } from './config';
-
-interface EigenFluxCredentials {
-  access_token: string;
-  email?: string;
-  expires_at?: number;
-}
-
-export type AuthState =
-  | {
-      status: 'available';
-      accessToken: string;
-      source: 'file';
-      credentialsPath: string;
-      expiresAt?: number;
-      email?: string;
-    }
-  | {
-      status: 'missing' | 'expired';
-      source?: 'file';
-      credentialsPath: string;
-      expiresAt?: number;
-      email?: string;
-    };
-
-export class CredentialsLoader {
-  private readonly logger: Logger;
-  private readonly workdir: string;
-
-  constructor(logger: Logger, workdir: string) {
-    this.logger = logger;
-    this.workdir = workdir;
-  }
-
-  loadAccessToken(): string | null {
-    const authState = this.loadAuthState();
-    if (authState.status !== 'available') {
-      if (authState.status === 'missing') {
-        this.logger.error(`No access token found in ${authState.credentialsPath}`);
-      }
-      return null;
-    }
-    return authState.accessToken;
-  }
-
-  loadAuthState(): AuthState {
-    const credentialsPath = this.resolveCredentialsPath();
-
-    if (fs.existsSync(credentialsPath)) {
-      try {
-        const content = fs.readFileSync(credentialsPath, 'utf-8');
-        const credentials: EigenFluxCredentials = JSON.parse(content);
-
-        if (credentials.access_token) {
-          if (credentials.expires_at) {
-            const now = Date.now();
-            if (now >= credentials.expires_at) {
-              this.logger.warn('Access token has expired');
-              return {
-                status: 'expired',
-                source: 'file',
-                credentialsPath,
-                expiresAt: credentials.expires_at,
-                email: credentials.email,
-              };
-            }
-          }
-
-          this.logger.info(`Loaded access token from ${credentialsPath}`);
-          return {
-            status: 'available',
-            accessToken: credentials.access_token,
-            source: 'file',
-            credentialsPath,
-            expiresAt: credentials.expires_at,
-            email: credentials.email,
-          };
-        }
-      } catch (error) {
-        this.logger.error(`Failed to read credentials file: ${credentialsPath}`, error);
-      }
-    }
-
-    return {
-      status: 'missing',
-      credentialsPath,
-    };
-  }
-
-  saveAccessToken(token: string, email?: string, expiresAt?: number): void {
-    const credentialsPath = this.resolveCredentialsPath();
-
-    if (!fs.existsSync(this.workdir)) {
-      fs.mkdirSync(this.workdir, { recursive: true });
-    }
-
-    const credentials: EigenFluxCredentials = {
-      access_token: token,
-      email,
-      expires_at: expiresAt,
-    };
-
-    try {
-      fs.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), 'utf-8');
-      this.logger.info(`Saved access token to ${credentialsPath}`);
-    } catch (error) {
-      this.logger.error('Failed to save credentials file', error);
-    }
-  }
-
-  private resolveCredentialsPath(): string {
-    return path.join(this.workdir, PLUGIN_CONFIG.CREDENTIALS_FILE);
-  }
-}

package/src/gateway-rpc-client.test.ts

@@ -1,190 +0,0 @@
-import http from 'http';
-import { WebSocketServer } from 'ws';
-import { OpenClawGatewayRpcClient } from './gateway-rpc-client';
-import { Logger } from './logger';
-
-describe('OpenClawGatewayRpcClient', () => {
-  let server: http.Server;
-  let wss: WebSocketServer;
-  let port: number;
-
-  beforeEach(async () => {
-    server = http.createServer();
-    wss = new WebSocketServer({ server });
-    await new Promise<void>((resolve) => {
-      server.listen(0, '127.0.0.1', () => {
-        port = (server.address() as any).port;
-        resolve();
-      });
-    });
-  });
-
-  afterEach(async () => {
-    await new Promise<void>((resolve) => wss.close(() => resolve()));
-    await new Promise<void>((resolve) => server.close(() => resolve()));
-  });
-
-  test('uses configured session key and sends agent directly', async () => {
-    const methods: string[] = [];
-    let agentParams: any = null;
-
-    wss.on('connection', (socket) => {
-      socket.send(
-        JSON.stringify({
-          type: 'event',
-          event: 'connect.challenge',
-          payload: { nonce: 'nonce-test-1' },
-        })
-      );
-
-      socket.on('message', (raw) => {
-        const frame = JSON.parse(raw.toString());
-        methods.push(String(frame.method || ''));
-
-        if (frame.method === 'connect') {
-          socket.send(
-            JSON.stringify({
-              type: 'res',
-              id: frame.id,
-              ok: true,
-              payload: {
-                protocol: 3,
-                server: { version: 'test', connId: 'conn-1' },
-                features: { methods: ['agent'], events: [] },
-                snapshot: { ts: Date.now() },
-                policy: { maxPayload: 1000000, maxBufferedBytes: 1000000, tickIntervalMs: 30000 },
-              },
-            })
-          );
-          return;
-        }
-
-        if (frame.method === 'agent') {
-          agentParams = frame.params;
-          socket.send(
-            JSON.stringify({
-              type: 'res',
-              id: frame.id,
-              ok: true,
-              payload: { status: 'started', runId: 'run-1' },
-            })
-          );
-        }
-      });
-    });
-
-    const client = new OpenClawGatewayRpcClient({
-      gatewayUrl: `ws://127.0.0.1:${port}`,
-      gatewayToken: 'gw_token_1',
-      sessionKey: 'agent:test:feishu:direct:ou_123',
-      agentId: 'test',
-      replyChannel: 'feishu',
-      replyTo: 'ou_123',
-      logger: new Logger({ info: jest.fn(), warn: jest.fn(), error: jest.fn(), debug: jest.fn() }),
-    });
-
-    const result = await client.sendAgentMessage('[EIGENFLUX_TEST] first payload');
-
-    expect(result).toEqual({
-      sessionKey: 'agent:test:feishu:direct:ou_123',
-      runId: 'run-1',
-    });
-    expect(methods).toEqual(['connect', 'agent']);
-    expect(agentParams).toEqual(
-      expect.objectContaining({
-        sessionKey: 'agent:test:feishu:direct:ou_123',
-        agentId: 'test',
-        message: '[EIGENFLUX_TEST] first payload',
-        deliver: true,
-        replyChannel: 'feishu',
-        replyTo: 'ou_123',
-      })
-    );
-  });
-
-  test('resolves session key from sessions.list when not configured', async () => {
-    const methods: string[] = [];
-    let agentParams: any = null;
-
-    wss.on('connection', (socket) => {
-      socket.send(
-        JSON.stringify({
-          type: 'event',
-          event: 'connect.challenge',
-          payload: { nonce: 'nonce-test-2' },
-        })
-      );
-
-      socket.on('message', (raw) => {
-        const frame = JSON.parse(raw.toString());
-        methods.push(String(frame.method || ''));
-
-        if (frame.method === 'connect') {
-          socket.send(
-            JSON.stringify({
-              type: 'res',
-              id: frame.id,
-              ok: true,
-              payload: {
-                protocol: 3,
-                server: { version: 'test', connId: 'conn-2' },
-                features: { methods: ['sessions.list', 'agent'], events: [] },
-                snapshot: { ts: Date.now() },
-                policy: { maxPayload: 1000000, maxBufferedBytes: 1000000, tickIntervalMs: 30000 },
-              },
-            })
-          );
-          return;
-        }
-
-        if (frame.method === 'sessions.list') {
-          socket.send(
-            JSON.stringify({
-              type: 'res',
-              id: frame.id,
-              ok: true,
-              payload: {
-                sessions: [{ key: 'agent:foo:main' }, { key: 'agent:foo:feishu:direct:ou_999', active: true }],
-              },
-            })
-          );
-          return;
-        }
-
-        if (frame.method === 'agent') {
-          agentParams = frame.params;
-          socket.send(
-            JSON.stringify({
-              type: 'res',
-              id: frame.id,
-              ok: true,
-              payload: { status: 'started', runId: 'run-2' },
-            })
-          );
-        }
-      });
-    });
-
-    const client = new OpenClawGatewayRpcClient({
-      gatewayUrl: `ws://127.0.0.1:${port}`,
-      gatewayToken: 'gw_token_2',
-      logger: new Logger({ info: jest.fn(), warn: jest.fn(), error: jest.fn(), debug: jest.fn() }),
-    });
-
-    const result = await client.sendAgentMessage('[EIGENFLUX_TEST] second payload');
-
-    expect(result).toEqual({
-      sessionKey: 'agent:foo:feishu:direct:ou_999',
-      runId: 'run-2',
-    });
-    expect(methods).toEqual(['connect', 'sessions.list', 'agent']);
-    expect(agentParams).toEqual(
-      expect.objectContaining({
-        sessionKey: 'agent:foo:feishu:direct:ou_999',
-        agentId: 'foo',
-        message: '[EIGENFLUX_TEST] second payload',
-        deliver: true,
-      })
-    );
-  });
-});