@phronesis-io/openclaw-eigenflux 0.0.1 → 0.0.2

package/src/config.test.ts

@@ -1,188 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-
-import {
-  PLUGIN_CONFIG,
-  resolvePluginConfig,
-  resolveServerSkillPath,
-} from './config';
-
-describe('resolvePluginConfig', () => {
-  test('prepends the default eigenflux server when servers is omitted', () => {
-    const config = resolvePluginConfig({});
-
-    expect(config.gatewayUrl).toBe(PLUGIN_CONFIG.DEFAULT_GATEWAY_URL);
-    expect(config.openclawCliBin).toBe(PLUGIN_CONFIG.DEFAULT_OPENCLAW_CLI_BIN);
-    expect(config.servers).toHaveLength(1);
-    expect(config.servers[0]).toEqual({
-      enabled: true,
-      name: 'eigenflux',
-      endpoint: PLUGIN_CONFIG.DEFAULT_ENDPOINT,
-      workdir: path.join(os.homedir(), '.openclaw/eigenflux'),
-      pollIntervalSec: PLUGIN_CONFIG.DEFAULT_POLL_INTERVAL_SEC,
-      pmPollIntervalSec: PLUGIN_CONFIG.DEFAULT_PM_POLL_INTERVAL_SEC,
-      sessionKey: PLUGIN_CONFIG.DEFAULT_SESSION_KEY,
-      agentId: PLUGIN_CONFIG.DEFAULT_AGENT_ID,
-      replyChannel: undefined,
-      replyTo: undefined,
-      replyAccountId: undefined,
-      routeOverrides: {
-        sessionKey: false,
-        agentId: false,
-        replyChannel: false,
-        replyTo: false,
-        replyAccountId: false,
-      },
-    });
-  });
-
-  test('prepends the default eigenflux server when no explicit eigenflux server exists', () => {
-    const config = resolvePluginConfig({
-      gatewayUrl: 'ws://127.0.0.1:29999',
-      openclawCliBin: '/opt/bin/openclaw',
-      servers: [
-        {
-          name: 'alpha',
-          endpoint: 'https://alpha.example.com',
-          workdir: '~/custom/alpha',
-          pollInterval: 45,
-          pmPollInterval: 30,
-          sessionKey: 'agent:ops:feishu:direct:ou_alpha',
-        },
-      ],
-    });
-
-    expect(config.gatewayUrl).toBe('ws://127.0.0.1:29999');
-    expect(config.openclawCliBin).toBe('/opt/bin/openclaw');
-    expect(config.servers).toHaveLength(2);
-    expect(config.servers[0]).toEqual(
-      expect.objectContaining({
-        name: 'eigenflux',
-        endpoint: PLUGIN_CONFIG.DEFAULT_ENDPOINT,
-        workdir: path.join(os.homedir(), '.openclaw/eigenflux'),
-      })
-    );
-    expect(config.servers[1]).toEqual({
-      enabled: true,
-      name: 'alpha',
-      endpoint: 'https://alpha.example.com',
-      workdir: path.join(os.homedir(), 'custom/alpha'),
-      pollIntervalSec: 45,
-      pmPollIntervalSec: 30,
-      sessionKey: 'agent:ops:feishu:direct:ou_alpha',
-      agentId: 'ops',
-      replyChannel: 'feishu',
-      replyTo: 'ou_alpha',
-      replyAccountId: undefined,
-      routeOverrides: {
-        sessionKey: true,
-        agentId: false,
-        replyChannel: false,
-        replyTo: false,
-        replyAccountId: false,
-      },
-    });
-  });
-
-  test('does not prepend another default server when eigenflux is explicitly configured', () => {
-    const config = resolvePluginConfig({
-      servers: [
-        {
-          name: 'eigenflux',
-          workdir: '~/custom/eigenflux',
-          pollInterval: 15,
-        },
-        {
-          name: 'alpha',
-          endpoint: 'https://alpha.example.com',
-        },
-      ],
-    });
-
-    expect(config.servers).toHaveLength(2);
-    expect(config.servers[0]).toEqual(
-      expect.objectContaining({
-        name: 'eigenflux',
-        endpoint: 'https://www.eigenflux.ai',
-        workdir: path.join(os.homedir(), 'custom/eigenflux'),
-        pollIntervalSec: 15,
-      })
-    );
-    expect(config.servers[1]).toEqual(
-      expect.objectContaining({
-        name: 'alpha',
-        endpoint: 'https://alpha.example.com',
-      })
-    );
-  });
-
-  test('creates unique names when duplicate server names are configured', () => {
-    const config = resolvePluginConfig({
-      servers: [{ name: 'eigenflux' }, { name: 'eigenflux' }, {}],
-    });
-
-    expect(config.servers.map((server) => server.name)).toEqual([
-      'eigenflux',
-      'eigenflux-2',
-      'server-3',
-    ]);
-    expect(config.servers[2].workdir).toBe(path.join(os.homedir(), '.openclaw/server-3'));
-  });
-
-  test('uses gateway auth token from host config when plugin config omits it', () => {
-    const config = resolvePluginConfig(
-      {
-        servers: [{ name: 'eigenflux' }],
-      },
-      {
-        gateway: {
-          auth: {
-            token: 'gw_host_token',
-          },
-        },
-      }
-    );
-
-    expect(config.gatewayToken).toBe('gw_host_token');
-  });
-});
-
-describe('resolveServerSkillPath', () => {
-  test('prefers local workdir skill.md when it exists', () => {
-    const workdir = fs.mkdtempSync(path.join(os.tmpdir(), 'eigenflux-skill-path-'));
-    const localSkillPath = path.join(workdir, 'skill.md');
-    fs.writeFileSync(localSkillPath, '# local skill\n', 'utf-8');
-
-    expect(
-      resolveServerSkillPath({
-        endpoint: 'https://example.com/root',
-        workdir,
-      })
-    ).toBe(localSkillPath);
-
-    fs.rmSync(workdir, { recursive: true, force: true });
-  });
-
-  test('falls back to endpoint skill.md when local file is absent', () => {
-    const workdir = fs.mkdtempSync(path.join(os.tmpdir(), 'eigenflux-skill-path-'));
-
-    expect(
-      resolveServerSkillPath({
-        endpoint: 'https://example.com/root',
-        workdir,
-      })
-    ).toBe('https://example.com/root/skill.md');
-
-    fs.rmSync(workdir, { recursive: true, force: true });
-  });
-});
-
-describe('PLUGIN_CONFIG USER_AGENT', () => {
-  test('includes eigenflux plugin version', () => {
-    expect(PLUGIN_CONFIG.USER_AGENT).toContain('eigenflux-plugin');
-    expect(PLUGIN_CONFIG.USER_AGENT).toContain('node/');
-    expect(PLUGIN_CONFIG.USER_AGENT).toMatch(/\(.*;\s*.*;\s*.*\)/);
-    expect(PLUGIN_CONFIG.PLUGIN_VERSION).toBe('0.0.1-alpha.0');
-  });
-});

package/src/config.ts

@@ -1,410 +0,0 @@
-/**
- * Internal configuration for the EigenFlux plugin.
- */
-
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-
-const PLUGIN_VERSION = '0.0.1-alpha.0';
-const DEFAULT_SERVER_NAME = 'eigenflux';
-const DEFAULT_ENDPOINT = 'https://www.eigenflux.ai';
-const DEFAULT_GATEWAY_URL = 'ws://127.0.0.1:18789';
-const DEFAULT_SESSION_KEY = 'main';
-const DEFAULT_AGENT_ID = 'main';
-const DEFAULT_OPENCLAW_CLI_BIN = 'openclaw';
-const DEFAULT_POLL_INTERVAL_SEC = 300;
-const DEFAULT_PM_POLL_INTERVAL_SEC = 60;
-
-export type NotificationRouteOverrides = {
-  sessionKey: boolean;
-  agentId: boolean;
-  replyChannel: boolean;
-  replyTo: boolean;
-  replyAccountId: boolean;
-};
-
-export type EigenFluxServerConfig = {
-  enabled?: boolean;
-  name?: string;
-  endpoint?: string;
-  workdir?: string;
-  pollInterval?: number;
-  pmPollInterval?: number;
-  sessionKey?: string;
-  agentId?: string;
-  replyChannel?: string;
-  replyTo?: string;
-  replyAccountId?: string;
-};
-
-export type EigenFluxPluginConfig = {
-  gatewayUrl?: string;
-  gatewayToken?: string;
-  openclawCliBin?: string;
-  servers?: EigenFluxServerConfig[];
-};
-
-export type ResolvedEigenFluxServerConfig = {
-  enabled: boolean;
-  name: string;
-  endpoint: string;
-  workdir: string;
-  pollIntervalSec: number;
-  pmPollIntervalSec: number;
-  sessionKey: string;
-  agentId: string;
-  replyChannel?: string;
-  replyTo?: string;
-  replyAccountId?: string;
-  routeOverrides: NotificationRouteOverrides;
-};
-
-export type ResolvedEigenFluxPluginConfig = {
-  gatewayUrl: string;
-  gatewayToken?: string;
-  openclawCliBin: string;
-  servers: ResolvedEigenFluxServerConfig[];
-};
-
-type GlobalGatewayConfig = {
-  gateway?: {
-    auth?: {
-      token?: string;
-    };
-  };
-};
-
-type DerivedNotificationRoute = {
-  agentId?: string;
-  replyChannel?: string;
-  replyTo?: string;
-  replyAccountId?: string;
-};
-
-function detectOpenClawVersion(): string | undefined {
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const pkg = require('openclaw/package.json') as { version?: string };
-    return pkg.version;
-  } catch {
-    return undefined;
-  }
-}
-
-function buildUserAgent(): string {
-  const parts: string[] = [];
-
-  parts.push(`node/${process.version.replace(/^v/, '')}`);
-  parts.push(`(${os.platform()}; ${os.arch()}; ${os.release()})`);
-
-  const openclawVersion = detectOpenClawVersion();
-  if (openclawVersion) {
-    parts.push(`openclaw/${openclawVersion}`);
-  }
-
-  parts.push(`eigenflux-plugin/${PLUGIN_VERSION}`);
-
-  return parts.join(' ');
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-function readNonEmptyString(value: unknown): string | undefined {
-  if (typeof value !== 'string') {
-    return undefined;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function parsePositiveInteger(value: unknown, fallback: number): number {
-  if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
-    return Math.floor(value);
-  }
-  if (typeof value === 'string') {
-    const parsed = parseInt(value, 10);
-    if (Number.isFinite(parsed) && parsed > 0) {
-      return parsed;
-    }
-  }
-  return fallback;
-}
-
-function isSessionPeerShape(value: string | undefined): boolean {
-  const normalized = value?.trim().toLowerCase();
-  return (
-    normalized === 'direct' ||
-    normalized === 'dm' ||
-    normalized === 'group' ||
-    normalized === 'channel'
-  );
-}
-
-function deriveNotificationRoute(sessionKey: string | undefined): DerivedNotificationRoute {
-  const trimmed = readNonEmptyString(sessionKey);
-  if (!trimmed) {
-    return {};
-  }
-
-  const parts = trimmed.split(':').filter((part) => part.length > 0);
-  if (parts.length < 3 || parts[0]?.toLowerCase() !== 'agent') {
-    return {};
-  }
-
-  const agentId = readNonEmptyString(parts[1]);
-  if (parts.length >= 6 && isSessionPeerShape(parts[4])) {
-    return {
-      agentId,
-      replyChannel: readNonEmptyString(parts[2]),
-      replyAccountId: readNonEmptyString(parts[3]),
-      replyTo: readNonEmptyString(parts.slice(5).join(':')),
-    };
-  }
-
-  if (parts.length >= 5 && isSessionPeerShape(parts[3])) {
-    return {
-      agentId,
-      replyChannel: readNonEmptyString(parts[2]),
-      replyTo: readNonEmptyString(parts.slice(4).join(':')),
-    };
-  }
-
-  return { agentId };
-}
-
-function createRouteOverrides(
-  normalized: Record<string, unknown>
-): NotificationRouteOverrides {
-  return {
-    sessionKey: readNonEmptyString(normalized.sessionKey) !== undefined,
-    agentId: readNonEmptyString(normalized.agentId) !== undefined,
-    replyChannel: readNonEmptyString(normalized.replyChannel) !== undefined,
-    replyTo: readNonEmptyString(normalized.replyTo) !== undefined,
-    replyAccountId: readNonEmptyString(normalized.replyAccountId) !== undefined,
-  };
-}
-
-function hasExplicitDefaultServer(servers: Record<string, unknown>[]): boolean {
-  return servers.some(
-    (server) => readNonEmptyString(server.name)?.toLowerCase() === DEFAULT_SERVER_NAME
-  );
-}
-
-function normalizeServersInput(config: Record<string, unknown>): EigenFluxServerConfig[] {
-  const explicitServers = Array.isArray(config.servers)
-    ? config.servers.filter(isRecord)
-    : [];
-
-  if (!hasExplicitDefaultServer(explicitServers)) {
-    return [{} as EigenFluxServerConfig, ...explicitServers];
-  }
-
-  return explicitServers;
-}
-
-function createServerName(baseName: string, usedNames: Set<string>): string {
-  if (!usedNames.has(baseName)) {
-    usedNames.add(baseName);
-    return baseName;
-  }
-
-  let suffix = 2;
-  while (usedNames.has(`${baseName}-${suffix}`)) {
-    suffix += 1;
-  }
-  const uniqueName = `${baseName}-${suffix}`;
-  usedNames.add(uniqueName);
-  return uniqueName;
-}
-
-function resolveServerConfig(
-  serverConfig: unknown,
-  index: number,
-  usedNames: Set<string>
-): ResolvedEigenFluxServerConfig {
-  const normalized = isRecord(serverConfig) ? serverConfig : {};
-  const rawName =
-    readNonEmptyString(normalized.name) ??
-    (index === 0 ? DEFAULT_SERVER_NAME : `server-${index + 1}`);
-  const name = createServerName(rawName, usedNames);
-  const sessionKey = readNonEmptyString(normalized.sessionKey) ?? DEFAULT_SESSION_KEY;
-  const derivedRoute = deriveNotificationRoute(sessionKey);
-  const workdir = expandHomeDir(
-    readNonEmptyString(normalized.workdir) ?? `~/.openclaw/${name}`
-  );
-  const sessionStorePath = readNonEmptyString(normalized.sessionStorePath);
-
-  return {
-    enabled: normalized.enabled !== false,
-    name,
-    endpoint: readNonEmptyString(normalized.endpoint) ?? DEFAULT_ENDPOINT,
-    workdir,
-    pollIntervalSec: parsePositiveInteger(normalized.pollInterval, DEFAULT_POLL_INTERVAL_SEC),
-    pmPollIntervalSec: parsePositiveInteger(
-      normalized.pmPollInterval,
-      DEFAULT_PM_POLL_INTERVAL_SEC
-    ),
-    sessionKey,
-    agentId: readNonEmptyString(normalized.agentId) ?? derivedRoute.agentId ?? DEFAULT_AGENT_ID,
-    replyChannel: readNonEmptyString(normalized.replyChannel) ?? derivedRoute.replyChannel,
-    replyTo: readNonEmptyString(normalized.replyTo) ?? derivedRoute.replyTo,
-    replyAccountId:
-      readNonEmptyString(normalized.replyAccountId) ?? derivedRoute.replyAccountId,
-    routeOverrides: createRouteOverrides(normalized),
-    ...(sessionStorePath ? { sessionStorePath: expandHomeDir(sessionStorePath) } : {}),
-  } as ResolvedEigenFluxServerConfig;
-}
-
-export function expandHomeDir(input: string): string {
-  if (input === '~') {
-    return os.homedir();
-  }
-  if (input.startsWith('~/')) {
-    return path.join(os.homedir(), input.slice(2));
-  }
-  return input;
-}
-
-function buildSkillUrl(endpoint: string): string {
-  try {
-    return new URL('skill.md', endpoint.endsWith('/') ? endpoint : `${endpoint}/`).toString();
-  } catch {
-    return `${endpoint.replace(/\/+$/u, '')}/skill.md`;
-  }
-}
-
-export function resolveServerSkillPath(server: {
-  endpoint: string;
-  workdir: string;
-}): string {
-  const localSkillPath = path.join(server.workdir, 'skill.md');
-  if (fs.existsSync(localSkillPath)) {
-    return localSkillPath;
-  }
-  return buildSkillUrl(server.endpoint);
-}
-
-export function resolvePluginConfig(
-  pluginConfig: unknown,
-  globalConfig?: GlobalGatewayConfig
-): ResolvedEigenFluxPluginConfig {
-  const normalized = isRecord(pluginConfig) ? pluginConfig : {};
-  const usedNames = new Set<string>();
-
-  return {
-    gatewayUrl: readNonEmptyString(normalized.gatewayUrl) ?? DEFAULT_GATEWAY_URL,
-    gatewayToken:
-      readNonEmptyString(normalized.gatewayToken) ??
-      readNonEmptyString(globalConfig?.gateway?.auth?.token),
-    openclawCliBin:
-      readNonEmptyString(normalized.openclawCliBin) ?? DEFAULT_OPENCLAW_CLI_BIN,
-    servers: normalizeServersInput(normalized).map((server, index) =>
-      resolveServerConfig(server, index, usedNames)
-    ),
-  };
-}
-
-const SERVER_CONFIG_SCHEMA = {
-  type: 'object',
-  additionalProperties: false,
-  properties: {
-    enabled: {
-      type: 'boolean',
-      description: 'Enable or disable background polling for this server',
-      default: true,
-    },
-    name: {
-      type: 'string',
-      description: 'Server name used for routing, workdir defaults, and diagnostics',
-      default: DEFAULT_SERVER_NAME,
-    },
-    endpoint: {
-      type: 'string',
-      description: 'EigenFlux API base URL for this server',
-      default: DEFAULT_ENDPOINT,
-    },
-    workdir: {
-      type: 'string',
-      description: 'Directory used to store server credentials and remembered session state',
-    },
-    pollInterval: {
-      type: 'integer',
-      minimum: 1,
-      description: 'Feed polling interval in seconds for this server',
-      default: DEFAULT_POLL_INTERVAL_SEC,
-    },
-    pmPollInterval: {
-      type: 'integer',
-      minimum: 1,
-      description: 'Private message polling interval in seconds for this server',
-      default: DEFAULT_PM_POLL_INTERVAL_SEC,
-    },
-    sessionKey: {
-      type: 'string',
-      description: 'Target session key used by runtime.subagent and heartbeat fallback',
-      default: DEFAULT_SESSION_KEY,
-    },
-    agentId: {
-      type: 'string',
-      description: 'Agent id used by Gateway agent and CLI fallbacks',
-      default: DEFAULT_AGENT_ID,
-    },
-    replyChannel: {
-      type: 'string',
-      description: 'Explicit reply channel used by Gateway agent and CLI fallbacks',
-    },
-    replyTo: {
-      type: 'string',
-      description: 'Explicit reply target used by Gateway agent and CLI fallbacks',
-    },
-    replyAccountId: {
-      type: 'string',
-      description: 'Optional reply account id for multi-account channel delivery',
-    },
-  },
-} as const;
-
-export const PLUGIN_CONFIG = {
-  DEFAULT_SERVER_NAME,
-  DEFAULT_ENDPOINT,
-  DEFAULT_GATEWAY_URL,
-  DEFAULT_SESSION_KEY,
-  DEFAULT_AGENT_ID,
-  DEFAULT_OPENCLAW_CLI_BIN,
-  DEFAULT_POLL_INTERVAL_SEC,
-  DEFAULT_PM_POLL_INTERVAL_SEC,
-  CREDENTIALS_FILE: 'credentials.json',
-  PLUGIN_VERSION,
-  USER_AGENT: buildUserAgent(),
-} as const;
-
-export const PLUGIN_CONFIG_SCHEMA = {
-  type: 'object',
-  additionalProperties: false,
-  properties: {
-    gatewayUrl: {
-      type: 'string',
-      description: 'OpenClaw Gateway WebSocket URL used for Gateway RPC fallback',
-      default: DEFAULT_GATEWAY_URL,
-    },
-    gatewayToken: {
-      type: 'string',
-      description: 'Optional gateway token override used for Gateway RPC fallback',
-    },
-    openclawCliBin: {
-      type: 'string',
-      description: 'OpenClaw CLI binary used by runtime command and spawn fallbacks',
-      default: DEFAULT_OPENCLAW_CLI_BIN,
-    },
-    servers: {
-      type: 'array',
-      description:
-        'Server list. When empty or when no server named eigenflux is provided, the plugin prepends a default eigenflux server.',
-      default: [],
-      items: SERVER_CONFIG_SCHEMA,
-    },
-  },
-} as const;

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,
-    });
-  });
-});