@phronesis-io/openclaw-eigenflux 0.0.4 → 0.0.7

package/dist/index.js

@@ -1,141 +1,227 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const polling_client_1 = require("./polling-client");
-const pm_polling_client_1 = require("./pm-polling-client");
+const stream_client_1 = require("./stream-client");
+const cli_executor_1 = require("./cli-executor");
 const logger_1 = require("./logger");
 const credentials_loader_1 = require("./credentials-loader");
 const config_1 = require("./config");
 const notification_route_resolver_1 = require("./notification-route-resolver");
 const agent_prompt_templates_1 = require("./agent-prompt-templates");
 const notifier_1 = require("./notifier");
+const reply_target_1 = require("./reply-target");
 const session_route_memory_1 = require("./session-route-memory");
-const COMMAND_NAMES = ['auth', 'profile', 'servers', 'feed', 'pm', 'here'];
+const COMMAND_NAMES = ['auth', 'profile', 'servers', 'feed', 'pm', 'here', 'version'];
 const COMMAND_NAME_SET = new Set(COMMAND_NAMES);
-function readServerSessionStorePath(server) {
-    return server
-        .sessionStorePath;
-}
+const DEFAULT_ROUTING = {
+    sessionKey: config_1.PLUGIN_CONFIG.DEFAULT_SESSION_KEY,
+    agentId: config_1.PLUGIN_CONFIG.DEFAULT_AGENT_ID,
+    routeOverrides: {
+        sessionKey: false,
+        agentId: false,
+        replyChannel: false,
+        replyTo: false,
+        replyAccountId: false,
+    },
+};
 function register(api) {
-    const logger = new logger_1.Logger(api.logger);
-    logger.info('EigenFlux activating...');
-    const pluginConfig = (0, config_1.resolvePluginConfig)(api.pluginConfig, api.config, logger);
-    const runtimes = pluginConfig.servers.map((server) => createServerRuntime(api, logger, pluginConfig, server));
-    const enabledRuntimes = runtimes.filter((runtime) => runtime.server.enabled);
-    if (!pluginConfig.gatewayToken) {
-        logger.warn('OpenClaw gateway token not found in config.gateway.auth.token or plugin config; Gateway RPC fallback may fail when gateway auth mode is token');
-    }
-    if (enabledRuntimes.length === 0) {
-        logger.warn('No enabled EigenFlux servers configured; background polling services will not start');
+    const logger = new logger_1.Logger(resolvePluginLogger(api));
+    const pluginConfig = (0, config_1.resolvePluginConfig)(api.pluginConfig, logger);
+    const eigenfluxHome = (0, config_1.resolveEigenfluxHome)();
+    let runtimes = [];
+    let notInstalledPromptDelivered = false;
+    // Register a single meta-service that discovers servers on start
+    api.registerService({
+        id: 'eigenflux:discovery',
+        start: async () => {
+            logger.info('Starting EigenFlux discovery service...');
+            const discovery = await (0, config_1.discoverServers)(pluginConfig.eigenfluxBin, logger);
+            if (discovery.kind === 'not_installed') {
+                logger.warn(`EigenFlux CLI not installed (bin=${discovery.bin}); delivering install prompt to user`);
+                if (!notInstalledPromptDelivered) {
+                    notInstalledPromptDelivered = true;
+                    await deliverNotInstalledPrompt(api, logger, pluginConfig, eigenfluxHome, discovery.bin);
+                }
+                return;
+            }
+            const servers = discovery.servers;
+            if (servers.length === 0) {
+                logger.warn('No EigenFlux servers discovered; services will not start');
+                return;
+            }
+            logger.info(`Discovered ${servers.length} server(s): ${servers.map((s) => s.name).join(', ')}`);
+            runtimes = servers.map((server) => createServerRuntime(api, logger, pluginConfig, server, eigenfluxHome));
+            for (const runtime of runtimes) {
+                logger.info(`Starting services for server=${runtime.server.name}`);
+                await runtime.feedPoller.start();
+                await runtime.streamClient.start();
+            }
+        },
+        stop: async () => {
+            logger.info('Stopping EigenFlux discovery service...');
+            for (const runtime of runtimes) {
+                logger.info(`Stopping services for server=${runtime.server.name}`);
+                runtime.feedPoller.stop();
+                await runtime.streamClient.stop();
+            }
+            runtimes = [];
+            notInstalledPromptDelivered = false;
+        },
+    });
+    registerCommand(api, logger, pluginConfig, eigenfluxHome, () => runtimes, (next) => {
+        runtimes = next;
+    });
+}
+function resolvePluginLogger(api) {
+    const runtimeLogging = api.runtime?.logging;
+    if (runtimeLogging && typeof runtimeLogging.getChildLogger === 'function') {
+        try {
+            const child = runtimeLogging.getChildLogger({ plugin: 'eigenflux' });
+            if (child) {
+                return child;
+            }
+        }
+        catch {
+            // fall through to api.logger
+        }
     }
-    registerServices(api, logger, enabledRuntimes);
-    registerCommand(api, logger, runtimes);
-    logger.info(`EigenFlux activated with ${enabledRuntimes.length}/${runtimes.length} enabled server(s)`);
+    return api.logger;
 }
 const plugin = {
     id: 'openclaw-eigenflux',
     name: 'EigenFlux',
-    description: 'OpenClaw extension for EigenFlux periodic polling with multi-server delivery',
+    description: 'OpenClaw extension for EigenFlux with CLI-based feed polling and PM streaming',
     configSchema: config_1.PLUGIN_CONFIG_SCHEMA,
     register,
 };
 exports.default = plugin;
-function createServerRuntime(api, logger, pluginConfig, server) {
-    const credentialsLoader = new credentials_loader_1.CredentialsLoader(logger, server.workdir);
+const INSTALL_COMMAND = 'curl -fsSL https://eigenflux.ai/install.sh | bash';
+async function deliverNotInstalledPrompt(api, logger, pluginConfig, _eigenfluxHome, bin) {
+    // Intentionally no workdir: the bootstrap notifier must not read or persist
+    // any remembered session route under <eigenfluxHome>/bootstrap.
     const notifier = new notifier_1.EigenFluxNotifier(api, logger, {
-        gatewayUrl: pluginConfig.gatewayUrl,
-        gatewayToken: pluginConfig.gatewayToken,
-        workdir: server.workdir,
-        sessionKey: server.sessionKey,
-        agentId: server.agentId,
-        replyChannel: server.replyChannel,
-        replyTo: server.replyTo,
-        replyAccountId: server.replyAccountId,
+        sessionKey: DEFAULT_ROUTING.sessionKey,
+        agentId: DEFAULT_ROUTING.agentId,
+        replyChannel: DEFAULT_ROUTING.replyChannel,
+        replyTo: DEFAULT_ROUTING.replyTo,
+        replyAccountId: DEFAULT_ROUTING.replyAccountId,
+        openclawCliBin: pluginConfig.openclawCliBin,
+        routeOverrides: DEFAULT_ROUTING.routeOverrides,
+    });
+    await notifier.deliver((0, agent_prompt_templates_1.buildNotInstalledPromptTemplate)({ bin, installCommand: INSTALL_COMMAND }));
+}
+function createServerRuntime(api, logger, pluginConfig, server, eigenfluxHome) {
+    const routing = pluginConfig.serverRouting[server.name] ?? DEFAULT_ROUTING;
+    const credentialsLoader = new credentials_loader_1.CredentialsLoader(logger, eigenfluxHome, server.name);
+    const notifier = new notifier_1.EigenFluxNotifier(api, logger, {
+        eigenfluxBin: pluginConfig.eigenfluxBin,
+        serverName: server.name,
+        sessionKey: routing.sessionKey,
+        agentId: routing.agentId,
+        replyChannel: routing.replyChannel,
+        replyTo: routing.replyTo,
+        replyAccountId: routing.replyAccountId,
         openclawCliBin: pluginConfig.openclawCliBin,
-        sessionStorePath: readServerSessionStorePath(server),
-        routeOverrides: server.routeOverrides,
+        routeOverrides: routing.routeOverrides,
     });
     const getPromptContext = () => ({
         serverName: server.name,
-        endpoint: server.endpoint,
-        workdir: server.workdir,
-        skillPath: (0, config_1.resolveServerSkillPath)(server),
+        eigenfluxHome,
     });
     let lastAuthPromptKey = null;
     const resetAuthPromptGate = () => {
         lastAuthPromptKey = null;
     };
     const notifyAuthRequired = async (authEvent) => {
-        const promptKey = `${authEvent.reason}:${authEvent.credentialsPath}:${authEvent.source || 'unknown'}`;
+        const promptKey = `auth_required:${server.name}`;
         if (lastAuthPromptKey === promptKey) {
-            logger.debug(`Skipping duplicate auth prompt for server=${server.name}, key=${promptKey}`);
+            logger.debug(`Skipping duplicate auth prompt for server=${server.name}`);
             return;
         }
         lastAuthPromptKey = promptKey;
-        const authState = credentialsLoader.loadAuthState();
-        await notifier.deliver(buildAuthRequiredMessage(getPromptContext(), {
-            authEvent,
-            authState,
-        }));
+        await notifier.deliver((0, agent_prompt_templates_1.buildAuthRequiredPromptTemplate)({ context: getPromptContext() }));
     };
-    const pollingClient = new polling_client_1.EigenFluxPollingClient({
-        apiUrl: server.endpoint,
-        getAuthState: () => credentialsLoader.loadAuthState(),
-        pollIntervalSec: server.pollIntervalSec,
+    const feedPoller = new polling_client_1.EigenFluxPollingClient({
+        serverName: server.name,
+        eigenfluxBin: pluginConfig.eigenfluxBin,
+        resolvePollIntervalSec: () => (0, polling_client_1.readPollIntervalSec)(pluginConfig.eigenfluxBin, server.name, logger),
         logger,
         onFeedPolled: async (payload) => {
             resetAuthPromptGate();
-            await notifier.deliver(buildFeedPayloadMessage(getPromptContext(), payload));
+            await notifier.deliver((0, agent_prompt_templates_1.buildFeedPayloadPromptTemplate)(payload, getPromptContext()));
         },
         onAuthRequired: notifyAuthRequired,
     });
-    const pmPollingClient = new pm_polling_client_1.EigenFluxPmPollingClient({
-        apiUrl: server.endpoint,
-        getAuthState: () => credentialsLoader.loadAuthState(),
-        pollIntervalSec: server.pmPollIntervalSec,
+    const streamClient = new stream_client_1.EigenFluxStreamClient({
+        serverName: server.name,
+        eigenfluxBin: pluginConfig.eigenfluxBin,
         logger,
-        onPmFetched: async (payload) => {
+        onPmEvent: async (event) => {
             resetAuthPromptGate();
-            await notifier.deliver(buildPmPayloadMessage(getPromptContext(), payload));
+            await notifier.deliver((0, agent_prompt_templates_1.buildPmStreamEventPromptTemplate)(event, getPromptContext()));
+        },
+        onAuthRequired: async () => {
+            await notifyAuthRequired({ reason: 'auth_required' });
         },
-        onAuthRequired: notifyAuthRequired,
     });
     return {
         server,
+        routing,
         credentialsLoader,
         notifier,
-        pollingClient,
-        pmPollingClient,
+        feedPoller,
+        streamClient,
         getPromptContext,
     };
 }
-function registerServices(api, logger, runtimes) {
-    for (const runtime of runtimes) {
-        api.registerService({
-            id: `eigenflux:${toServiceIdSegment(runtime.server.name)}`,
-            start: async () => {
-                logger.info(`Starting EigenFlux polling services for server=${runtime.server.name}`);
-                await runtime.pollingClient.start();
-                await runtime.pmPollingClient.start();
-            },
-            stop: async () => {
-                logger.info(`Stopping EigenFlux polling services for server=${runtime.server.name}`);
-                runtime.pollingClient.stop();
-                runtime.pmPollingClient.stop();
-            },
-        });
-    }
-}
-function registerCommand(api, logger, runtimes) {
+// ─── Command Handler ────────────────────────────────────────────────────────
+function registerCommand(api, logger, pluginConfig, eigenfluxHome, getRuntimes, setRuntimes) {
     if (!api.registerCommand) {
         logger.warn('registerCommand API unavailable; skipping /eigenflux command registration');
         return;
     }
+    let inflightDiscovery = null;
+    const runDiscovery = async () => {
+        const discovery = await (0, config_1.discoverServers)(pluginConfig.eigenfluxBin, logger);
+        if (discovery.kind === 'not_installed') {
+            return { runtimes: getRuntimes(), notInstalledBin: discovery.bin };
+        }
+        if (discovery.servers.length === 0) {
+            return { runtimes: getRuntimes() };
+        }
+        const created = discovery.servers.map((server) => createServerRuntime(api, logger, pluginConfig, server, eigenfluxHome));
+        setRuntimes(created);
+        return { runtimes: created };
+    };
+    const ensureRuntimes = async () => {
+        const existing = getRuntimes();
+        if (existing.length > 0) {
+            return { runtimes: existing };
+        }
+        if (!inflightDiscovery) {
+            inflightDiscovery = runDiscovery().finally(() => {
+                inflightDiscovery = null;
+            });
+        }
+        return inflightDiscovery;
+    };
     api.registerCommand({
         name: 'eigenflux',
-        description: 'EigenFlux plugin commands: auth, profile, servers, feed, pm, here',
+        description: 'EigenFlux plugin commands: auth, profile, servers, feed, pm, here, version',
         acceptsArgs: true,
         handler: async (ctx) => {
             const parsed = parseCommandArgs(ctx.args);
+            if (parsed.command === 'version') {
+                return {
+                    text: await buildVersionText(pluginConfig.eigenfluxBin),
+                };
+            }
+            const { runtimes, notInstalledBin } = await ensureRuntimes();
+            if (notInstalledBin && runtimes.length === 0) {
+                return {
+                    text: `EigenFlux CLI not installed (bin=${notInstalledBin}). Install with: ${INSTALL_COMMAND}`,
+                };
+            }
             if (parsed.command === 'servers') {
                 return {
                     text: buildServersText(runtimes),
@@ -148,27 +234,27 @@ function registerCommand(api, logger, runtimes) {
                 };
             }
             const runtime = selection.runtime;
-            await rememberCurrentCommandRouteIfPossible(ctx, runtime.server, logger);
+            await rememberCurrentCommandRouteIfPossible(ctx, runtime, pluginConfig.eigenfluxBin, logger);
             switch (parsed.command) {
                 case 'auth':
                     return {
-                        text: buildAuthStatusText(runtime.server, runtime.credentialsLoader.loadAuthState()),
+                        text: buildAuthStatusText(runtime),
                     };
                 case 'profile':
                     return {
-                        text: await buildProfileText(runtime, runtime.credentialsLoader.loadAuthState()),
+                        text: await buildProfileText(runtime, pluginConfig.eigenfluxBin),
                     };
                 case 'feed':
                     return {
-                        text: await buildFeedText(runtime, runtime.credentialsLoader.loadAuthState()),
+                        text: await buildFeedText(runtime),
                     };
                 case 'pm':
                     return {
-                        text: await buildPmPollText(runtime, runtime.credentialsLoader.loadAuthState()),
+                        text: buildPmStatusText(runtime),
                     };
                 case 'here':
                     return {
-                        text: await buildHereText(ctx, runtime.server, logger),
+                        text: await buildHereText(ctx, runtime, pluginConfig.eigenfluxBin, logger),
                     };
                 default:
                     return {
@@ -200,7 +286,7 @@ function parseCommandArgs(args) {
 function selectServerRuntime(runtimes, requestedServerName) {
     if (runtimes.length === 0) {
         return {
-            error: 'No EigenFlux servers are configured.',
+            error: 'No EigenFlux servers discovered. Ensure eigenflux CLI is configured with at least one server.',
         };
     }
     if (!requestedServerName) {
@@ -222,19 +308,19 @@ function selectServerRuntime(runtimes, requestedServerName) {
 }
 function buildServersText(runtimes) {
     if (runtimes.length === 0) {
-        return 'No EigenFlux servers are configured.';
+        return 'No EigenFlux servers discovered.';
     }
-    const defaultRuntime = runtimes[0];
     return [
-        'EigenFlux servers:',
+        'EigenFlux servers (discovered via CLI):',
         ...runtimes.map((runtime) => {
             const flags = [
-                runtime.server.enabled ? 'enabled' : 'disabled',
-                defaultRuntime?.server.name === runtime.server.name ? 'default' : null,
+                runtime.server.current ? 'default' : null,
+                runtime.streamClient.isRunning() ? 'streaming' : null,
             ]
                 .filter(Boolean)
                 .join(', ');
-            return `- ${runtime.server.name}: ${flags}; endpoint=${runtime.server.endpoint}; workdir=${runtime.server.workdir}`;
+            const suffix = flags ? ` (${flags})` : '';
+            return `- ${runtime.server.name}: endpoint=${runtime.server.endpoint}${suffix}`;
         }),
     ].join('\n');
 }
@@ -248,23 +334,13 @@ function buildHelpText(runtimes) {
             ? `Available servers: ${runtimes.map((runtime) => runtime.server.name).join(', ')}`
             : undefined,
         '',
-        '/eigenflux auth',
-        'Show current EigenFlux credential status.',
-        '',
-        '/eigenflux profile',
-        'Fetch /api/v1/agents/me with the current access token.',
-        '',
-        '/eigenflux servers',
-        'List configured EigenFlux servers.',
-        '',
-        '/eigenflux feed',
-        'Run one feed refresh and return the raw feed payload.',
-        '',
-        '/eigenflux pm',
-        'Run one PM fetch and return the raw PM payload.',
-        '',
-        '/eigenflux here',
-        'Remember the current conversation as the default delivery route for the selected server.',
+        '/eigenflux auth — Show credential status',
+        '/eigenflux profile — Fetch agent profile',
+        '/eigenflux servers — List discovered servers',
+        '/eigenflux feed — Run one feed refresh',
+        '/eigenflux pm — Show PM stream status',
+        '/eigenflux here — Remember current conversation as delivery route',
+        '/eigenflux version — Show eigenflux CLI version info',
     ]
         .filter(Boolean)
         .join('\n');
@@ -287,98 +363,51 @@ function isInternalAgentSessionKey(value) {
     const parts = trimmed.split(':').filter((part) => part.length > 0);
     return parts[0]?.toLowerCase() === 'agent' && parts[2]?.toLowerCase() === 'main';
 }
-function isNormalizedConversationTarget(value) {
-    return /^(user|chat|channel|room):/u.test(value);
-}
-function normalizeReplyTarget(value, channel, fallbackKind) {
-    const trimmed = readNonEmptyString(value);
-    if (!trimmed) {
-        return undefined;
-    }
-    if (isNormalizedConversationTarget(trimmed)) {
-        return trimmed;
-    }
-    if (channel && trimmed.startsWith(`${channel}:`)) {
-        const inner = trimmed.slice(channel.length + 1).trim();
-        if (isNormalizedConversationTarget(inner)) {
-            return inner;
-        }
-        return fallbackKind ? `${fallbackKind}:${inner}` : inner;
-    }
-    return fallbackKind ? `${fallbackKind}:${trimmed}` : trimmed;
-}
-async function resolveCurrentCommandRoute(ctx, serverConfig, logger) {
-    const channel = normalizeChannel(ctx.channel);
-    const accountId = readNonEmptyString(ctx.accountId);
-    let replyChannel = channel;
-    let replyTo = normalizeReplyTarget(ctx.to, channel) ?? normalizeReplyTarget(ctx.from, channel, 'user');
-    let replyAccountId = accountId;
+async function resolveCurrentCommandRoute(ctx, runtime, logger) {
+    let channel = normalizeChannel(ctx.channel);
+    let to = (0, reply_target_1.normalizeReplyTarget)(ctx.to, { channel }) ??
+        (0, reply_target_1.normalizeReplyTarget)(ctx.from, { channel, fallbackKind: 'user' });
+    let accountId = readNonEmptyString(ctx.accountId);
     if (typeof ctx.getCurrentConversationBinding === 'function') {
         try {
             const binding = await ctx.getCurrentConversationBinding();
             if (binding) {
-                replyChannel = normalizeChannel(binding.channel) ?? replyChannel;
-                replyTo =
-                    normalizeReplyTarget(binding.conversationId, replyChannel) ??
-                        normalizeReplyTarget(binding.parentConversationId, replyChannel) ??
-                        replyTo;
-                replyAccountId = readNonEmptyString(binding.accountId) ?? replyAccountId;
+                channel = normalizeChannel(binding.channel) ?? channel;
+                to =
+                    (0, reply_target_1.normalizeReplyTarget)(binding.conversationId, { channel }) ??
+                        (0, reply_target_1.normalizeReplyTarget)(binding.parentConversationId, { channel }) ??
+                        to;
+                accountId = readNonEmptyString(binding.accountId) ?? accountId;
             }
         }
         catch (error) {
             logger.debug(`Failed to read current conversation binding: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    if (!replyChannel || !replyTo) {
+    if (!channel || !to) {
         return undefined;
     }
-    const route = (0, notification_route_resolver_1.resolveNotificationRoute)({
-        sessionKey: 'main',
-        agentId: serverConfig.agentId,
-        replyChannel,
-        replyTo,
-        replyAccountId,
-        sessionStorePath: readServerSessionStorePath(serverConfig),
-        workdir: serverConfig.workdir,
-        routeOverrides: {
-            sessionKey: false,
-            agentId: false,
-            replyChannel: true,
-            replyTo: true,
-            replyAccountId: replyAccountId !== undefined,
-        },
+    return (0, notification_route_resolver_1.findSessionRouteForBinding)({
+        agentId: runtime.routing.agentId,
+        channel,
+        to,
+        accountId,
     }, logger);
-    if (!route.replyChannel || !route.replyTo) {
-        return undefined;
-    }
-    if (isInternalAgentSessionKey(route.sessionKey)) {
-        const configuredSessionKey = readNonEmptyString(serverConfig.sessionKey);
-        if (configuredSessionKey && !isInternalAgentSessionKey(configuredSessionKey)) {
-            return {
-                sessionKey: configuredSessionKey,
-                agentId: readNonEmptyString(serverConfig.agentId) ?? route.agentId,
-                replyChannel: route.replyChannel,
-                replyTo: route.replyTo,
-                replyAccountId: route.replyAccountId,
-            };
-        }
-    }
-    return route;
 }
-async function buildHereText(ctx, serverConfig, logger) {
-    const route = await resolveCurrentCommandRoute(ctx, serverConfig, logger);
+async function buildHereText(ctx, runtime, eigenfluxBin, logger) {
+    const route = await resolveCurrentCommandRoute(ctx, runtime, logger);
     if (!route || route.sessionKey === 'main' || route.sessionKey.endsWith(':main')) {
         return [
-            `Unable to resolve the current external session for server=${serverConfig.name}.`,
+            `Unable to resolve the current external session for server=${runtime.server.name}.`,
             'Run `/eigenflux here` inside the target conversation after OpenClaw has already created a session for it.',
         ].join('\n');
     }
-    const saved = (0, session_route_memory_1.writeStoredNotificationRoute)(serverConfig.workdir, route, logger);
+    const saved = await (0, session_route_memory_1.writeStoredNotificationRoute)(eigenfluxBin, runtime.server.name, route, logger);
     if (!saved) {
-        return `Failed to persist the current EigenFlux route for server=${serverConfig.name}; check plugin logs for details.`;
+        return `Failed to persist the current EigenFlux route for server=${runtime.server.name}; check plugin logs for details.`;
     }
     return [
-        `EigenFlux server ${serverConfig.name} will deliver to this conversation by default:`,
+        `EigenFlux server ${runtime.server.name} will deliver to this conversation by default:`,
         `sessionKey: ${route.sessionKey}`,
         `agentId: ${route.agentId}`,
         `channel: ${route.replyChannel ?? 'unknown'}`,
@@ -388,42 +417,52 @@ async function buildHereText(ctx, serverConfig, logger) {
         .filter(Boolean)
         .join('\n');
 }
-async function rememberCurrentCommandRouteIfPossible(ctx, serverConfig, logger) {
-    const route = await resolveCurrentCommandRoute(ctx, serverConfig, logger);
+async function rememberCurrentCommandRouteIfPossible(ctx, runtime, eigenfluxBin, logger) {
+    const route = await resolveCurrentCommandRoute(ctx, runtime, logger);
     if (!route || route.sessionKey === 'main' || route.sessionKey.endsWith(':main')) {
         return;
     }
-    if ((0, session_route_memory_1.writeStoredNotificationRoute)(serverConfig.workdir, route, logger)) {
-        logger.debug(`Remembered current command route for server=${serverConfig.name}: session_key=${route.sessionKey}, channel=${route.replyChannel ?? 'unknown'}, to=${route.replyTo ?? 'unknown'}`);
+    if (await (0, session_route_memory_1.writeStoredNotificationRoute)(eigenfluxBin, runtime.server.name, route, logger)) {
+        logger.debug(`Remembered current command route for server=${runtime.server.name}: session_key=${route.sessionKey}, channel=${route.replyChannel ?? 'unknown'}, to=${route.replyTo ?? 'unknown'}`);
     }
 }
-async function buildProfileText(runtime, authState) {
-    if (authState.status !== 'available') {
-        return buildAuthRequiredMessage(runtime.getPromptContext(), {
-            authEvent: {
-                reason: authState.status === 'expired' ? 'expired_token' : 'missing_token',
-                credentialsPath: authState.credentialsPath,
-                source: authState.source,
-                expiresAt: authState.expiresAt,
-            },
-            authState,
-        });
+// ─── Command Handlers ───────────────────────────────────────────────────────
+function buildAuthStatusText(runtime) {
+    const authState = runtime.credentialsLoader.loadAuthState();
+    const lines = [`EigenFlux auth status (server=${runtime.server.name}):`];
+    lines.push(`- credentials_path: ${authState.credentialsPath}`);
+    lines.push(`- status: ${authState.status}`);
+    if (authState.expiresAt) {
+        lines.push(`- expires_at: ${authState.expiresAt}`);
     }
-    try {
-        const payload = await fetchJson(`${runtime.server.endpoint}/api/v1/agents/me`, authState.accessToken);
-        return [
-            `EigenFlux profile (server=${runtime.server.name}):`,
-            '```json',
-            safeJsonStringify(payload),
-            '```',
-        ].join('\n');
+    if (authState.status === 'available') {
+        lines.push(`- token: ${maskToken(authState.accessToken)}`);
+    }
+    else {
+        lines.push('- token: unavailable');
     }
-    catch (error) {
-        return `Failed to fetch profile for server ${runtime.server.name}: ${error instanceof Error ? error.message : String(error)}`;
+    return lines.join('\n');
+}
+async function buildProfileText(runtime, eigenfluxBin) {
+    const result = await (0, cli_executor_1.execEigenflux)(eigenfluxBin, ['profile', 'show', '-s', runtime.server.name, '-f', 'json']);
+    if (result.kind === 'auth_required') {
+        return (0, agent_prompt_templates_1.buildAuthRequiredPromptTemplate)({ context: runtime.getPromptContext() });
     }
+    if (result.kind === 'not_installed') {
+        return `EigenFlux CLI not installed (bin=${result.bin}). Install with: ${INSTALL_COMMAND}`;
+    }
+    if (result.kind === 'error') {
+        return `Failed to fetch profile for server ${runtime.server.name}: ${result.error.message}`;
+    }
+    return [
+        `EigenFlux profile (server=${runtime.server.name}):`,
+        '```json',
+        safeJsonStringify(result.data),
+        '```',
+    ].join('\n');
 }
-async function buildFeedText(runtime, authState) {
-    const result = await runtime.pollingClient.pollOnce({
+async function buildFeedText(runtime) {
+    const result = await runtime.feedPoller.pollOnce({
         notifyFeed: false,
         notifyAuthRequired: false,
     });
@@ -436,89 +475,41 @@ async function buildFeedText(runtime, authState) {
                 '```',
             ].join('\n');
         case 'auth_required':
-            return buildAuthRequiredMessage(runtime.getPromptContext(), {
-                authEvent: result.authEvent,
-                authState,
-            });
+            return (0, agent_prompt_templates_1.buildAuthRequiredPromptTemplate)({ context: runtime.getPromptContext() });
         case 'error':
             return `EigenFlux feed failed for server ${runtime.server.name}: ${result.error.message}`;
         default:
             return `EigenFlux feed finished with an unknown result for server ${runtime.server.name}.`;
     }
 }
-async function buildPmPollText(runtime, authState) {
-    const result = await runtime.pmPollingClient.pollOnce({
-        notifyFeed: false,
-        notifyAuthRequired: false,
-    });
-    switch (result.kind) {
-        case 'success':
-            return [
-                `EigenFlux PM poll result (server=${runtime.server.name}):`,
-                '```json',
-                safeJsonStringify(result.payload),
-                '```',
-            ].join('\n');
-        case 'auth_required':
-            return buildAuthRequiredMessage(runtime.getPromptContext(), {
-                authEvent: result.authEvent,
-                authState,
-            });
-        case 'error':
-            return `EigenFlux PM poll failed for server ${runtime.server.name}: ${result.error.message}`;
-        default:
-            return `EigenFlux PM poll finished with an unknown result for server ${runtime.server.name}.`;
+async function buildVersionText(eigenfluxBin) {
+    const result = await (0, cli_executor_1.execEigenflux)(eigenfluxBin, ['version']);
+    if (result.kind === 'not_installed') {
+        return `EigenFlux CLI not installed (bin=${result.bin}). Install with: ${INSTALL_COMMAND}`;
     }
-}
-async function fetchJson(url, accessToken) {
-    const response = await fetch(url, {
-        method: 'GET',
-        headers: (0, config_1.buildEigenFluxRequestHeaders)(accessToken),
-    });
-    if (response.status === 401) {
-        throw new Error('HTTP 401: unauthorized');
+    if (result.kind === 'auth_required') {
+        return `EigenFlux CLI reported auth_required while fetching version (stderr: ${result.stderr || 'n/a'}).`;
     }
-    if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    if (result.kind === 'error') {
+        return `Failed to fetch eigenflux version: ${result.error.message}`;
     }
-    const payload = (await response.json());
-    if (payload.code !== 0) {
-        throw new Error(`API error: ${payload.msg}`);
-    }
-    return payload;
+    const body = typeof result.data === 'string' ? result.data : safeJsonStringify(result.data);
+    return ['EigenFlux CLI version:', '```json', body, '```'].join('\n');
 }
-function buildAuthStatusText(serverConfig, authState) {
-    const lines = [`EigenFlux auth status (server=${serverConfig.name}):`];
-    lines.push(`- workdir: ${serverConfig.workdir}`);
-    lines.push(`- credentials_path: ${authState.credentialsPath}`);
-    lines.push(`- status: ${authState.status}`);
-    if (authState.source) {
-        lines.push(`- source: ${authState.source}`);
+function buildPmStatusText(runtime) {
+    const running = runtime.streamClient.isRunning();
+    const cursor = runtime.streamClient.getLastCursor();
+    const lines = [`EigenFlux PM stream status (server=${runtime.server.name}):`];
+    lines.push(`- streaming: ${running ? 'active' : 'inactive'}`);
+    if (cursor) {
+        lines.push(`- last_cursor: ${cursor}`);
     }
-    if (authState.expiresAt) {
-        lines.push(`- expires_at: ${authState.expiresAt}`);
-    }
-    if (authState.status === 'available') {
-        lines.push(`- token: ${maskToken(authState.accessToken)}`);
-    }
-    else {
-        lines.push('- token: unavailable');
+    if (!running) {
+        lines.push('PM stream is not running. Check auth status or restart the service.');
     }
     return lines.join('\n');
 }
-function buildAuthRequiredMessage(promptContext, { authEvent, authState }) {
-    return (0, agent_prompt_templates_1.buildAuthRequiredPromptTemplate)({
-        ...promptContext,
-        authEvent,
-        maskedToken: authState?.status === 'available' ? maskToken(authState.accessToken) : undefined,
-    });
-}
-function buildFeedPayloadMessage(promptContext, payload) {
-    return (0, agent_prompt_templates_1.buildFeedPayloadPromptTemplate)(payload, promptContext);
-}
-function buildPmPayloadMessage(promptContext, payload) {
-    return (0, agent_prompt_templates_1.buildPmPayloadPromptTemplate)(payload, promptContext);
-}
+// ─── Utilities ──────────────────────────────────────────────────────────────
 function maskToken(token) {
     const trimmed = token.trim();
     if (trimmed.length <= 10) {
@@ -534,8 +525,4 @@ function safeJsonStringify(value) {
         return String(value);
     }
 }
-function toServiceIdSegment(name) {
-    const sanitized = name.trim().toLowerCase().replace(/[^a-z0-9._-]+/gu, '-');
-    return sanitized || 'default';
-}
 //# sourceMappingURL=index.js.map