@senpi/runtime 1.0.95-dev.20260408174401

package/dist/index.js

@@ -0,0 +1,772 @@
+/**
+ * Senpi core trading plugin — single plugin exposing all core features:
+ * actions, scanners, dsl, risk, health.
+ * Default export: OpenClaw plugin entry (register(api)).
+ * Named export run(): programmatic/standalone entry.
+ */
+import { join } from "node:path";
+import { SenpiClient } from "./senpi/client.js";
+import { buildRuntimeStateDir, archiveStateDir } from "./runtime/state-layout.js";
+import { registerSenpiCli } from "./cli/senpi-commands.js";
+import { readSenpiCliStore, resolveSenpiApiKeyFromStore, resolveSenpiBaseStateDir, resolveTelegramChatIdFromStore, } from "./cli/senpi-cli-config.js";
+import { getDefaultStateDir } from "./runtime/default-state-dir.js";
+import { createNotificationService } from "./runtime/notifications.js";
+import { run } from "./runtime/run.js";
+import { AutoUpdateCoordinator } from "./runtime/auto-update/coordinator.js";
+import { runCommand } from "./runtime/auto-update/command-runner.js";
+import { resolveAutoUpdateConfig } from "./runtime/auto-update/types.js";
+import { createScannerProvidersForRun } from "./runtime/create-scanner-providers-for-run.js";
+import { initDsl } from "./dsl/index.js";
+import { initHealth } from "./health/index.js";
+import { initRisk } from "./risk/index.js";
+import { VERSION } from "./version.js";
+import { setErrorNotifier, } from "./utils/logger.js";
+/** Initialize all core features (DSL, risk, health) on the given event bus. */
+export function initCore(bus) {
+    initDsl(bus);
+    initRisk(bus);
+    initHealth(bus);
+}
+// DSL feature (exit/dsl component, types, config)
+export { initDsl, DslPlugin, dslLogger, setDslLogLevel, parseDslPluginConfig, DslConfigValidationError, dslValidationIssue, EVENTS as DslEvents, DSL_EVENTS, } from "./dsl/index.js";
+// Risk feature (placeholder)
+export { initRisk } from "./risk/index.js";
+// Health feature
+export { createHealthStateModule, initHealth } from "./health/index.js";
+// Shared types
+export { HOOK_EVENT } from './types/index.js';
+export { ScanStatus } from './types/index.js';
+export { DecisionEngine, LlmDecisionStrategy, NoDecisionStrategy, } from './actions/decision-engine.js';
+export { OpenClawLlmDecision, AnthropicLlmDecision, createLlmDecision } from './actions/llm-decision/index.js';
+/** @deprecated Use OpenClawLlmDecision instead */
+export { OpenClawLlmDecision as LlmDecisionClient } from './actions/llm-decision/index.js';
+export { OpenPositionAction, openPositionFactory, openPositionManifest, } from './actions/open-position/open-position.action.js';
+export { ClosePositionAction, closePositionFactory, closePositionManifest, } from './actions/close-position/close-position.action.js';
+// Senpi client
+export { SenpiClient } from './senpi/index.js';
+// Scanner runtime module
+export { createScannerRuntimeModule, createSenpiScannerProviders, emergingMoversScanner, momentumScanner, oiTrackerScanner, providerInput, prescreenerScanner, PersistencePolicy, RetentionPolicy, ScanStatus as ScannerScanStatus, SkipScan, } from './scanners/index.js';
+// Runtime loader — programmatic API and OpenClaw plugin entry
+export { run } from "./runtime/run.js";
+export { loadRuntimeConfig } from "./runtime/load-runtime-config.js";
+export { Runtime } from "./runtime/runtime.js";
+function toSerializable(value, seen = new WeakSet()) {
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            stack: value.stack,
+            cause: toSerializable(value.cause, seen),
+        };
+    }
+    if (typeof value === "bigint")
+        return value.toString();
+    if (value == null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (Array.isArray(value))
+        return value.map((v) => toSerializable(v, seen));
+    if (typeof value === "object") {
+        const obj = value;
+        if (seen.has(obj))
+            return "[Circular]";
+        seen.add(obj);
+        const out = {};
+        for (const key of Object.keys(obj).sort()) {
+            out[key] = toSerializable(obj[key], seen);
+        }
+        seen.delete(obj);
+        return out;
+    }
+    return String(value);
+}
+function stringifyForTelegram(value) {
+    try {
+        return JSON.stringify(toSerializable(value), null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function trimTelegramMessage(message, maxLength = 3900) {
+    if (message.length <= maxLength)
+        return message;
+    const clipped = message.slice(0, maxLength);
+    return `${clipped}\n...[truncated ${message.length - maxLength} chars]`;
+}
+function formatSharedLoggerErrorNotification(payload) {
+    const lines = [
+        "Senpi error log",
+        "source: shared-logger",
+        `timestamp: ${payload.timestamp}`,
+        `namespace: ${payload.namespace}`,
+        `level: ${payload.level}`,
+        `message: ${payload.message}`,
+    ];
+    if (payload.meta !== undefined) {
+        lines.push(`meta:\n${stringifyForTelegram(payload.meta)}`);
+    }
+    return trimTelegramMessage(lines.join("\n"));
+}
+function formatApiLoggerErrorNotification(message, meta) {
+    const msg = typeof message === "string" ? message : stringifyForTelegram(message);
+    const lines = [
+        "Senpi error log",
+        "source: plugin-api-logger",
+        `timestamp: ${new Date().toISOString()}`,
+        `message: ${msg}`,
+    ];
+    if (meta !== undefined) {
+        lines.push(`meta:\n${stringifyForTelegram(meta)}`);
+    }
+    return trimTelegramMessage(lines.join("\n"));
+}
+function fireAndForgetErrorNotification(notifications, message) {
+    if (!notifications)
+        return;
+    try {
+        void notifications.notify(message).catch(() => { });
+    }
+    catch {
+        // Intentionally swallow; error notifications must never fail call sites.
+    }
+}
+/**
+ * OpenClaw plugin entry.
+ * Boots from internal registry (installed_runtimes.json) in stateDir; does not read runtime list from config.
+ */
+const senpiRuntimePlugin = {
+    id: "@senpi-ai/runtime",
+    name: "Senpi Trading Runtime",
+    version: VERSION,
+    description: "Senpi trading runtime plugin for OpenClaw — orchestrates scanners, actions, and DSL exit engine",
+    configSchema: {
+        parse(value) {
+            if (value && typeof value === "object" && !Array.isArray(value)) {
+                return value;
+            }
+            return {};
+        },
+    },
+    register(api) {
+        const pluginLogger = {
+            info: (...args) => api.logger.info(...args),
+            warn: (...args) => api.logger.warn(...args),
+            error: (message, meta) => api.logger.error(message, meta),
+        };
+        pluginLogger.info("[senpi-runtime] register(api) invoked");
+        const config = api.pluginConfig;
+        if (!config) {
+            pluginLogger.warn("[senpi-runtime] No plugin config found — skipping registration");
+            return;
+        }
+        const senpiCliStore = readSenpiCliStore();
+        const baseStateDir = resolveSenpiBaseStateDir({
+            store: senpiCliStore,
+            configStateDir: typeof config.stateDir === "string" ? config.stateDir : undefined,
+            resolveOpenclawStateDir: typeof api.runtime?.state?.resolveStateDir === "function"
+                ? () => api.runtime.state.resolveStateDir()
+                : undefined,
+            getDefaultStateDir,
+        });
+        const mcpTransport = api.mcpTransport;
+        const apiKey = resolveSenpiApiKeyFromStore(senpiCliStore, typeof config.apiKey === "string" && config.apiKey.length > 0 ? config.apiKey : undefined);
+        if (!mcpTransport && !apiKey) {
+            pluginLogger.error("[senpi-runtime] mcpTransport or apiKey is required (provide via gateway, api, or config)");
+            return;
+        }
+        const runtimeHandles = new Map();
+        const lifecycleChatId = resolveTelegramChatIdFromStore(senpiCliStore);
+        const lifecycleNotifications = lifecycleChatId
+            ? createNotificationService({
+                telegram_chat_id: lifecycleChatId,
+                gateway_url: process.env.OPENCLAW_GATEWAY_URL || "http://127.0.0.1:18789",
+                gateway_token: process.env.OPENCLAW_GATEWAY_TOKEN,
+            })
+            : undefined;
+        setErrorNotifier(lifecycleNotifications
+            ? (payload) => {
+                fireAndForgetErrorNotification(lifecycleNotifications, formatSharedLoggerErrorNotification(payload));
+            }
+            : null);
+        pluginLogger.error = (message, meta) => {
+            api.logger.error(message, meta);
+            fireAndForgetErrorNotification(lifecycleNotifications, formatApiLoggerErrorNotification(message, meta));
+        };
+        const autoUpdateConfig = resolveAutoUpdateConfig(config?.autoUpdate);
+        const autoUpdateCoordinator = new AutoUpdateCoordinator({
+            enabled: true,
+            config: autoUpdateConfig,
+            packageName: "@senpi-ai/runtime",
+            currentVersion: VERSION,
+            stateDir: join(baseStateDir, "auto-update"),
+            logger: pluginLogger,
+            notify: lifecycleNotifications
+                ? (msg) => lifecycleNotifications.notify(msg)
+                : async () => { },
+            stopRuntimesForUpdate: async () => {
+                for (const [, handle] of runtimeHandles) {
+                    await handle.stop();
+                }
+            },
+            runUpdateCommand: async () => {
+                const result = await runCommand("sh", ["-lc", "yes | openclaw plugins update runtime"], {
+                    timeoutMs: 120_000,
+                });
+                if (result.code !== 0) {
+                    throw new Error(result.stderr || `openclaw plugins update failed with code ${result.code}`);
+                }
+            },
+            configFromApi: api.config,
+            loadConfig: api.runtime?.config
+                ? () => api.runtime.config.loadConfig()
+                : undefined,
+            writeConfigFile: api.runtime?.config
+                ? (c) => api.runtime.config.writeConfigFile(c)
+                : undefined,
+            pluginId: api.id,
+        });
+        api.registerService({
+            id: "senpi-runtime",
+            async start() {
+                await autoUpdateCoordinator.start();
+                const { readRegistry } = await import("./runtime/strategy-registry.js");
+                const registry = await readRegistry(baseStateDir);
+                const scannerProviders = await createScannerProvidersForRun({
+                    mcpTransport,
+                    apiKey,
+                });
+                const started = [];
+                try {
+                    for (const entry of registry.runtimes) {
+                        const hasPath = typeof entry.runtimeYamlPath === "string" && entry.runtimeYamlPath.length > 0;
+                        const hasContent = typeof entry.runtimeYamlContent === "string";
+                        if (hasPath && hasContent)
+                            continue;
+                        if (!hasPath && !hasContent)
+                            continue;
+                        const pathOrContent = entry.runtimeYamlPath ?? entry.runtimeYamlContent;
+                        const entryStateDir = buildRuntimeStateDir(baseStateDir, entry.id, entry.wallet ?? "");
+                        const handle = await run(pathOrContent, {
+                            fromPath: hasPath,
+                            stateDir: entryStateDir,
+                            mcpTransport,
+                            apiKey,
+                            scannerProviders,
+                        });
+                        runtimeHandles.set(entry.id, handle);
+                        started.push(entry.id);
+                    }
+                }
+                catch (err) {
+                    for (let i = started.length - 1; i >= 0; i--) {
+                        const h = runtimeHandles.get(started[i]);
+                        if (h)
+                            await h.stop().catch(() => { });
+                        runtimeHandles.delete(started[i]);
+                    }
+                    throw err;
+                }
+                pluginLogger.info(`[senpi-runtime] Started ${started.length} runtime${started.length === 1 ? "" : "s"}`);
+                if (lifecycleNotifications) {
+                    const n = started.length;
+                    lifecycleNotifications
+                        .notify(`Senpi started. ${n} runtime${n === 1 ? "" : "s"} running.`)
+                        .catch(() => { });
+                }
+                else if (started.length > 0) {
+                    pluginLogger.info("[senpi-runtime] Lifecycle notification skipped (set telegram-chat-id via `openclaw senpi config set-chat-id` or TELEGRAM_CHAT_ID / SENPI_LIFECYCLE_TELEGRAM_CHAT_ID)");
+                }
+            },
+            async stop() {
+                if (lifecycleNotifications) {
+                    lifecycleNotifications.notify("Senpi shutting down.").catch(() => { });
+                }
+                // Stop the coordinator first so it cannot schedule a new tick or call
+                // stopRuntimesForUpdate() while we are tearing down the handles below.
+                await autoUpdateCoordinator.stop();
+                const ids = Array.from(runtimeHandles.keys());
+                for (let i = ids.length - 1; i >= 0; i--) {
+                    const h = runtimeHandles.get(ids[i]);
+                    if (h)
+                        await h.stop();
+                    runtimeHandles.delete(ids[i]);
+                }
+                pluginLogger.info("[senpi-runtime] All runtimes stopped");
+            },
+        });
+        pluginLogger.info("[senpi-runtime] calling api.registerCli(..., { commands: ['senpi'] })");
+        api.registerCli((ctx) => {
+            pluginLogger.info("[senpi-runtime] CLI registrar callback invoked — attaching senpi subcommands to program");
+            registerSenpiCli(ctx.program);
+        }, { commands: ["senpi"] });
+        /** Gateway respond accepts (ok, payload?, error?) with error as { code, message }; plugin SDK types may omit the third arg. */
+        api.registerGatewayMethod("senpi.installRuntime", async (ctx) => {
+            const { params } = ctx;
+            const respond = ctx.respond;
+            const toError = (message) => ({ code: "INVALID_REQUEST", message });
+            const toUnavailable = (message) => ({ code: "UNAVAILABLE", message });
+            const { readRegistry, writeRegistry, validateEntry, hasId, deriveRuntimeId, sanitizeId } = await import("./runtime/strategy-registry.js");
+            const id = typeof params?.id === "string" ? params.id : undefined;
+            const runtimeYamlPath = typeof params?.runtimeYamlPath === "string" ? params.runtimeYamlPath : undefined;
+            const runtimeYamlContent = typeof params?.runtimeYamlContent === "string" ? params.runtimeYamlContent : undefined;
+            const hasPath = runtimeYamlPath !== undefined && runtimeYamlPath.length > 0;
+            const hasContent = runtimeYamlContent !== undefined;
+            if (!hasPath && !hasContent) {
+                respond(false, undefined, toError("Please provide your runtime YAML: use the create command with --path <file> or --content \"<yaml text>\"."));
+                return;
+            }
+            if (hasPath && hasContent) {
+                respond(false, undefined, toError("Please provide either a file path (--path) or YAML content (--content), not both."));
+                return;
+            }
+            const pathOrContent = runtimeYamlPath ?? runtimeYamlContent;
+            // Parse YAML first to extract name, version, and wallet for ID derivation.
+            let parsedSchemaVersion;
+            let runtimeName = "";
+            let wallet = "";
+            try {
+                const { loadRuntimeConfig } = await import("./runtime/load-runtime-config.js");
+                const { extractMajorVersion } = await import("./runtime/runtime-version.js");
+                const parsedConfig = await loadRuntimeConfig(pathOrContent, { fromPath: hasPath });
+                parsedSchemaVersion = extractMajorVersion(parsedConfig.version);
+                runtimeName = parsedConfig.name;
+                wallet = parsedConfig.strategy?.wallet ?? "";
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                respond(false, undefined, toUnavailable(`Could not start the runtime. This is usually due to invalid or incomplete YAML.\n\n${msg}`));
+                return;
+            }
+            const registry = await readRegistry(baseStateDir);
+            const resolvedId = id && id.length > 0
+                ? (sanitizeId(id) || "runtime")
+                : deriveRuntimeId(runtimeName, wallet);
+            if (hasId(registry, resolvedId)) {
+                respond(false, undefined, toError(`A runtime with id "${resolvedId}" already exists. Use a different id (e.g. --runtime-id another-name) or remove the existing one first: openclaw senpi runtime delete ${resolvedId}`));
+                return;
+            }
+            // Enforce one running runtime per wallet address
+            if (wallet) {
+                for (const [existingId, existingHandle] of runtimeHandles) {
+                    if (existingHandle.wallet === wallet) {
+                        respond(false, undefined, toError(`A runtime for wallet "${wallet}" is already running (runtime "${existingId}"). ` +
+                            `Stop it first: openclaw senpi runtime delete --id ${existingId}`));
+                        return;
+                    }
+                }
+            }
+            // Best-effort wallet ownership validation: calls the MCP server to check
+            // whether the wallet belongs to the authenticated user's strategies.
+            // If the MCP call fails (network issue, bad apiKey, server down), we warn
+            // and allow the install to proceed rather than blocking the user.
+            if (wallet) {
+                try {
+                    const client = mcpTransport
+                        ? new SenpiClient(mcpTransport)
+                        : new SenpiClient({ apiKey });
+                    if (!mcpTransport)
+                        await client.connect();
+                    try {
+                        const strategies = await client.listStrategies({ strategyAddresses: [wallet] });
+                        const match = strategies.find((s) => s.strategyWalletAddress.toLowerCase() === wallet.toLowerCase());
+                        if (!match) {
+                            pluginLogger.info("[senpi-runtime] Wallet validation failed: not owned", { wallet });
+                            respond(false, undefined, toError(`Strategy wallet "${wallet}" (YAML field: strategy.wallet) was not found in your Senpi account's strategies. ` +
+                                `Check the address for typos. ` +
+                                `To list all your strategies and their wallet addresses, call the MCP tool: strategy_list (no arguments needed). ` +
+                                `Each result includes "strategyWalletAddress" — use that value as strategy.wallet in your YAML.`));
+                            // `return` triggers the inner `finally` (disconnect) before exiting.
+                            return;
+                        }
+                        if (match.status !== "ACTIVE") {
+                            pluginLogger.info("[senpi-runtime] Wallet validation failed: strategy not active", { wallet, status: match.status, strategyId: match.id });
+                            respond(false, undefined, toError((() => {
+                                const initializingStatuses = new Set([
+                                    "SET_REFERRER_CODE", "SET_BUILDER_FEE", "SUBSCRIBE_TRADER",
+                                    "CREATE_WALLET", "FUND_WALLET", "INITIALIZE_POSITIONS",
+                                ]);
+                                const terminalStatuses = new Set([
+                                    "CLOSED", "FAILED", "CLOSING_POSITIONS", "CLOSE_STRATEGY",
+                                    "UNSUBSCRIBE_TRADER", "FUND_SOURCE_WALLET", "INACTIVE",
+                                ]);
+                                let hint;
+                                if (initializingStatuses.has(match.status)) {
+                                    hint =
+                                        `The strategy is still initializing (${match.status}). ` +
+                                            `It will reach ACTIVE automatically — wait a few minutes, then retry. ` +
+                                            `Initialization order: CREATE_WALLET → FUND_WALLET → INITIALIZE_POSITIONS → ACTIVE.`;
+                                }
+                                else if (match.status === "PAUSED") {
+                                    hint =
+                                        `The strategy is paused and cannot be used to create a runtime  — please create a new strategy instead.`;
+                                }
+                                else if (terminalStatuses.has(match.status)) {
+                                    hint =
+                                        `The strategy is closing or already closed (${match.status}). ` +
+                                            `A runtime cannot be created for a closed strategy — please create a new strategy instead.`;
+                                }
+                                else {
+                                    hint = `Only ACTIVE strategies can run a runtime.`;
+                                }
+                                return (`Strategy wallet "${wallet}" (YAML field: strategy.wallet) has status "${match.status}" — a runtime requires ACTIVE status. ` +
+                                    hint +
+                                    ` To check the latest status, call the MCP tool: strategy_list.`);
+                            })()));
+                            return;
+                        }
+                        pluginLogger.info("[senpi-runtime] Wallet validation passed", { wallet, strategyId: match.id, status: match.status });
+                    }
+                    finally {
+                        if (!mcpTransport)
+                            await client.disconnect().catch(() => { });
+                    }
+                }
+                catch (err) {
+                    // Soft-fail: validation is best-effort. If connect() or listStrategies()
+                    // throws, log a warning and let the install proceed.
+                    const msg = err instanceof Error ? err.message : String(err);
+                    pluginLogger.warn("[senpi-runtime] Could not validate strategy wallet ownership", { wallet, err: msg });
+                }
+            }
+            const entry = hasPath
+                ? { id: resolvedId, runtimeYamlPath, schemaVersion: parsedSchemaVersion, wallet }
+                : { id: resolvedId, runtimeYamlContent: runtimeYamlContent, schemaVersion: parsedSchemaVersion, wallet };
+            const valid = validateEntry(entry);
+            if (!valid.ok) {
+                respond(false, undefined, toError(valid.error));
+                return;
+            }
+            registry.runtimes.push(entry);
+            await writeRegistry(baseStateDir, registry);
+            try {
+                const scannerProviders = await createScannerProvidersForRun({
+                    mcpTransport,
+                    apiKey,
+                });
+                const entryStateDir = buildRuntimeStateDir(baseStateDir, resolvedId, wallet);
+                const handle = await run(pathOrContent, {
+                    fromPath: hasPath,
+                    stateDir: entryStateDir,
+                    mcpTransport,
+                    apiKey,
+                    scannerProviders,
+                });
+                runtimeHandles.set(resolvedId, handle);
+                respond(true, { id: resolvedId, name: runtimeName, wallet });
+            }
+            catch (err) {
+                const next = registry.runtimes.filter((e) => e.id !== resolvedId);
+                await writeRegistry(baseStateDir, { ...registry, runtimes: next });
+                const msg = err instanceof Error ? err.message : String(err);
+                respond(false, undefined, toUnavailable(`Could not start the runtime. This is usually due to invalid or incomplete YAML.\n\n${msg}`));
+            }
+        });
+        api.registerGatewayMethod("senpi.listRuntimes", async (ctx) => {
+            const respond = ctx.respond;
+            const { readRegistry } = await import("./runtime/strategy-registry.js");
+            const registry = await readRegistry(baseStateDir);
+            const runtimes = registry.runtimes.map((e) => ({
+                id: e.id,
+                wallet: e.wallet ?? "",
+                source: typeof e.runtimeYamlPath === "string" && e.runtimeYamlPath.length > 0 ? e.runtimeYamlPath : "(inline)",
+                status: runtimeHandles.has(e.id) ? "running" : "stopped",
+            }));
+            respond(true, { runtimes });
+        });
+        api.registerGatewayMethod("senpi.deleteRuntime", async (ctx) => {
+            const { params } = ctx;
+            const respond = ctx.respond;
+            const { readRegistry, writeRegistry } = await import("./runtime/strategy-registry.js");
+            const registry = await readRegistry(baseStateDir);
+            let targetId = typeof params?.id === "string" ? params.id : undefined;
+            const targetAddress = typeof params?.address === "string" ? params.address : undefined;
+            // Resolve target by address if id not provided
+            if (!targetId && targetAddress) {
+                const entry = registry.runtimes.find((e) => e.wallet === targetAddress);
+                if (!entry) {
+                    respond(false, undefined, {
+                        code: "NOT_FOUND",
+                        message: `No runtime found for wallet address "${targetAddress}".`,
+                    });
+                    return;
+                }
+                targetId = entry.id;
+            }
+            if (!targetId) {
+                respond(false, undefined, {
+                    code: "INVALID_REQUEST",
+                    message: "Please provide the runtime id or wallet address. Example: openclaw senpi runtime delete --id my-runtime",
+                });
+                return;
+            }
+            const handle = runtimeHandles.get(targetId);
+            if (handle) {
+                await handle.teardownDslForRuntimeDeletion();
+                await handle.stop();
+                runtimeHandles.delete(targetId);
+            }
+            // Archive state directory before removing from registry
+            const deletedEntry = registry.runtimes.find((e) => e.id === targetId);
+            if (deletedEntry) {
+                const runtimeStateDir = buildRuntimeStateDir(baseStateDir, targetId, deletedEntry.wallet ?? "");
+                const archivesDir = join(baseStateDir, "archives");
+                try {
+                    const archivePath = await archiveStateDir(runtimeStateDir, archivesDir, targetId, deletedEntry.wallet ?? "");
+                    api.logger.info(`[senpi-runtime] Archived state to ${archivePath}`);
+                }
+                catch (err) {
+                    api.logger.warn("[senpi-runtime] Failed to archive state dir", { err });
+                }
+            }
+            const next = registry.runtimes.filter((e) => e.id !== targetId);
+            await writeRegistry(baseStateDir, { ...registry, runtimes: next });
+            respond(true, { id: targetId });
+        });
+        api.registerGatewayMethod("senpi.listDslPositions", async (ctx) => {
+            const respond = ctx.respond;
+            const runtimeId = typeof ctx.params?.runtimeId === "string" ? ctx.params.runtimeId : undefined;
+            const address = typeof ctx.params?.address === "string" ? ctx.params.address : undefined;
+            pluginLogger.info("[senpi-runtime] senpi.listDslPositions", { runtimeId, address });
+            const positions = [];
+            for (const [id, handle] of runtimeHandles) {
+                if (runtimeId && id !== runtimeId)
+                    continue;
+                if (!handle.dsl)
+                    continue;
+                try {
+                    const items = handle.dsl.listActivePositions();
+                    for (const s of items) {
+                        if (address && s.address !== address)
+                            continue;
+                        positions.push({ ...s, runtimeId: id });
+                    }
+                }
+                catch (err) {
+                    pluginLogger.warn("[senpi-runtime] listDslPositions error", { runtimeId: id, err });
+                }
+            }
+            respond(true, { positions });
+        });
+        api.registerGatewayMethod("senpi.getDslPositionState", async (ctx) => {
+            const respond = ctx.respond;
+            const asset = typeof ctx.params?.asset === "string" ? ctx.params.asset : undefined;
+            if (!asset) {
+                respond(false, undefined, { code: "INVALID_REQUEST", message: "asset is required" });
+                return;
+            }
+            const runtimeId = typeof ctx.params?.runtimeId === "string" ? ctx.params.runtimeId : undefined;
+            const address = typeof ctx.params?.address === "string" ? ctx.params.address : undefined;
+            pluginLogger.info("[senpi-runtime] senpi.getDslPositionState", { asset, runtimeId, address });
+            const matches = [];
+            for (const [id, handle] of runtimeHandles) {
+                if (runtimeId && id !== runtimeId)
+                    continue;
+                if (!handle.dsl)
+                    continue;
+                try {
+                    if (address) {
+                        const state = handle.dsl.getPositionState(address, asset);
+                        if (state)
+                            matches.push({ runtimeId: id, address, state });
+                    }
+                    else {
+                        const found = handle.dsl.findPositionByAsset(asset);
+                        if (found)
+                            matches.push({ runtimeId: id, address: found.address, state: found.state });
+                    }
+                }
+                catch (err) {
+                    pluginLogger.warn("[senpi-runtime] getDslPositionState error", { runtimeId: id, err });
+                }
+            }
+            if (matches.length === 0) {
+                respond(false, undefined, {
+                    code: "NOT_FOUND",
+                    message: `No active DSL position found for asset ${asset}`,
+                });
+                return;
+            }
+            respond(true, { positions: matches });
+        });
+        api.registerGatewayMethod("senpi.listDslArchives", async (ctx) => {
+            const respond = ctx.respond;
+            const runtimeId = typeof ctx.params?.runtimeId === "string" ? ctx.params.runtimeId : undefined;
+            const address = typeof ctx.params?.address === "string" ? ctx.params.address : undefined;
+            const limit = typeof ctx.params?.limit === "number" ? ctx.params.limit : undefined;
+            pluginLogger.info("[senpi-runtime] senpi.listDslArchives", { runtimeId, address, limit });
+            let closes = [];
+            for (const [id, handle] of runtimeHandles) {
+                if (runtimeId && id !== runtimeId)
+                    continue;
+                if (!handle.dsl)
+                    continue;
+                try {
+                    const items = await handle.dsl.listArchivedCloses({ address });
+                    for (const c of items)
+                        closes.push({ ...c, runtimeId: id });
+                }
+                catch (err) {
+                    pluginLogger.warn("[senpi-runtime] listDslArchives error", { runtimeId: id, err });
+                }
+            }
+            closes.sort((a, b) => (b.closedAt ?? "").localeCompare(a.closedAt ?? ""));
+            if (limit && limit > 0)
+                closes = closes.slice(0, limit);
+            respond(true, { closes });
+        });
+        api.registerGatewayMethod("senpi.getHealthStatus", async (ctx) => {
+            const respond = ctx.respond;
+            const updater = autoUpdateCoordinator.getSnapshot();
+            const runtimeId = typeof ctx.params?.runtimeId === "string" ? ctx.params.runtimeId : undefined;
+            if (runtimeId) {
+                const handle = getRuntimeHandleOrRespond(runtimeHandles, runtimeId, respond);
+                if (!handle) {
+                    return;
+                }
+                try {
+                    const status = await handle.getHealthStatus();
+                    respond(true, {
+                        status: status ? { ...status, runtimeId } : null,
+                        updater,
+                    });
+                }
+                catch (err) {
+                    api.logger.warn("[senpi-runtime] getHealthStatus error", { runtimeId, err });
+                    respond(false, undefined, {
+                        code: "INTERNAL_ERROR",
+                        message: `Failed to get health status for runtime ${runtimeId}: ${formatGatewayError(err)}`,
+                    });
+                }
+                return;
+            }
+            const statuses = await collectRuntimeHealthStatuses(runtimeHandles, api.logger);
+            respond(true, { statuses, updater });
+        });
+        api.registerGatewayMethod("senpi.getSystemState", async (ctx) => {
+            const respond = ctx.respond;
+            const updater = autoUpdateCoordinator.getSnapshot();
+            const runtimeId = typeof ctx.params?.runtimeId === "string" ? ctx.params.runtimeId : undefined;
+            if (runtimeId) {
+                const handle = getRuntimeHandleOrRespond(runtimeHandles, runtimeId, respond);
+                if (!handle) {
+                    return;
+                }
+                try {
+                    const state = await handle.getSystemState();
+                    respond(true, {
+                        state: state ? { ...state, runtimeId } : null,
+                        updater,
+                    });
+                }
+                catch (err) {
+                    api.logger.warn("[senpi-runtime] getSystemState error", { runtimeId, err });
+                    respond(false, undefined, {
+                        code: "INTERNAL_ERROR",
+                        message: `Failed to get system state for runtime ${runtimeId}: ${formatGatewayError(err)}`,
+                    });
+                }
+                return;
+            }
+            const states = await collectRuntimeSystemStates(runtimeHandles, api.logger, baseStateDir);
+            respond(true, { states, updater });
+        });
+        api.logger.info(`[senpi-runtime] v${VERSION} plugin registered — stateDir: ${baseStateDir}`);
+    },
+};
+function getRuntimeHandleOrRespond(runtimeHandles, runtimeId, respond) {
+    const handle = runtimeHandles.get(runtimeId);
+    if (handle) {
+        return handle;
+    }
+    respond(false, undefined, {
+        code: "NOT_FOUND",
+        message: `No running runtime found for id ${runtimeId}`,
+    });
+    return null;
+}
+async function collectRuntimeHealthStatuses(runtimeHandles, logger) {
+    return (await Promise.all(Array.from(runtimeHandles, async ([runtimeId, handle]) => {
+        try {
+            const status = await handle.getHealthStatus();
+            return status ? { ...status, runtimeId } : null;
+        }
+        catch (err) {
+            logger.warn("[senpi-runtime] getHealthStatus error", { runtimeId, err });
+            return createGatewayHealthErrorStatus(runtimeId, err);
+        }
+    }))).filter((status) => status !== null);
+}
+async function collectRuntimeSystemStates(runtimeHandles, logger, baseStateDir) {
+    return (await Promise.all(Array.from(runtimeHandles, async ([runtimeId, handle]) => {
+        try {
+            const state = await handle.getSystemState();
+            return state ? { ...state, runtimeId } : null;
+        }
+        catch (err) {
+            logger.warn("[senpi-runtime] getSystemState error", { runtimeId, err });
+            return createGatewaySystemStateError(runtimeId, join(baseStateDir, runtimeId), err);
+        }
+    }))).filter((state) => state !== null);
+}
+function createGatewayHealthErrorStatus(runtimeId, error) {
+    const now = new Date().toISOString();
+    const message = formatGatewayError(error);
+    return {
+        runtimeId,
+        runtimeName: runtimeId,
+        startedAt: now,
+        generatedAt: now,
+        health: "unhealthy",
+        components: {
+            scanners: {
+                component: "scanners",
+                health: "unhealthy",
+                updatedAt: now,
+                summary: "Failed to query scanners health.",
+                error: message,
+                totals: {
+                    registered: 0,
+                    enabled: 0,
+                    inFlight: 0,
+                    degraded: 0,
+                    unhealthy: 1,
+                },
+                scanners: [],
+            },
+        },
+    };
+}
+function createGatewaySystemStateError(runtimeId, stateDir, error) {
+    const now = new Date().toISOString();
+    const message = formatGatewayError(error);
+    return {
+        runtimeId,
+        runtimeName: runtimeId,
+        stateDir,
+        startedAt: now,
+        generatedAt: now,
+        health: "unhealthy",
+        components: {
+            scanners: {
+                component: "scanners",
+                health: "unhealthy",
+                updatedAt: now,
+                error: message,
+                state: {
+                    totalRegistered: 0,
+                    totalEnabled: 0,
+                    scanners: [],
+                },
+            },
+        },
+    };
+}
+function formatGatewayError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export default senpiRuntimePlugin;
+//# sourceMappingURL=index.js.map