@senpi/runtime 3.0.171 → 3.0.180

package/dist/index.js

@@ -28,6 +28,7 @@ import { checkProofCoversRecipe, makeApplyToRuntime, makeWriteRegistry, runtimeC
 import { INSTALL_DEADLINE_MS, WALLET_INSTALL_IN_FLIGHT_CODE } from "./deploy/deadlines.js";
 import { AuditQueryError } from "./runtime/audit-query.types.js";
 import { buildRuntimeStateDir, archiveStateDir } from "./runtime/state-layout.js";
+import { KeyedMutex } from "./utils/keyed-mutex.js";
 import { describeRuntimeEntry } from "./runtime/runtime-descriptor.js";
 import { registerSenpiCli } from "./cli/senpi-commands.js";
 import { readSenpiCliStore, resolveSenpiApiKeyFromStore, resolveSenpiBaseStateDir, } from "./cli/senpi-cli-config.js";
@@ -39,6 +40,7 @@ import { resolveAutoUpdateConfig } from "./runtime/auto-update/types.js";
 import { SkillsCoordinatorUnavailableError, SkillsUpdateCoordinator, resolveSkillsManagerConfig, } from "./skills-manager/index.js";
 import { createScannerProvidersForRun } from "./runtime/create-scanner-providers-for-run.js";
 import { initDsl } from "./dsl/index.js";
+import { exchangeStopClass } from "./dsl/engine/index.js";
 import { initHealth } from "./health/index.js";
 import { initRisk } from "./risk/index.js";
 import { readRiskAuditEntries } from "./risk/risk-audit-log.js";
@@ -184,6 +186,12 @@ const WALLET_INSTALL_IN_FLIGHT = `[${WALLET_INSTALL_IN_FLIGHT_CODE}]`;
  * anyone's money is being claimed, which is precisely why it must not answer with the wallet code.
  */
 const RUNTIME_ID_TAKEN = "[E_RUNTIME_ID_TAKEN]";
+/**
+ * One StrategyFacts send per runtime at a time, keyed on runtime id, across the whole process: a
+ * second `register()` in the same process shares it. Separate from `runtimeChangeLock`. Delete does
+ * not take it; an apply queues its send here and does not wait.
+ */
+const factsSendLock = new KeyedMutex();
 /**
  * OpenClaw plugin entry.
  * Boots from internal registry (installed_runtimes.json) in stateDir; does not read runtime list from config.
@@ -487,7 +495,7 @@ const senpiRuntimePlugin = {
         // PluginLogger surface (info/warn/error) lacks `debug`, while the
         // Logger contract used by `runtime-api/` includes it.
         const apiLogger = createLogger("[senpi-core][api]");
-        /** One line per instance for the boot StrategyFacts send (ticket 125); see `sendBootFacts`. */
+        /** One line per instance for each StrategyFacts send; see `queueFactsSend`. */
         const factsLogger = createLogger("[senpi-core][strategy-facts]");
         // A gateway seam failed to wire/launch a runtime's external scanner stack: the runtime is up but
         // runs blind on internal scanners only. Two records, by design: a first-class `runtime.scanners_unwired`
@@ -759,26 +767,16 @@ const senpiRuntimePlugin = {
                     emitEvent(apiLogger, () => buildRuntimeBootSkippedEvent({ runtimeId: entry.id, address: entry.wallet ?? "", status }));
                 }
                 const started = [];
-                const factsPlans = [];
+                // Started runtimes with a facts plan, in boot order; their send runs detached after boot, below.
+                const factsRuntimeIds = [];
                 try {
                     for (const entry of entriesToBoot) {
-                        const hasPath = typeof entry.runtimeYamlPath === "string" && entry.runtimeYamlPath.length > 0;
-                        const hasContent = typeof entry.runtimeYamlContent === "string";
-                        if (hasPath && hasContent)
+                        const inputs = factsPlanInputs(entry);
+                        if (!inputs)
                             continue;
-                        if (!hasPath && !hasContent)
-                            continue;
-                        const pathOrContent = entry.runtimeYamlPath ?? entry.runtimeYamlContent;
-                        const entryStateDir = buildRuntimeStateDir(baseStateDir, entry.id, entry.wallet ?? "");
-                        // Local only (files, no network); the send itself runs detached after boot, below.
-                        const factsPlan = await planInstanceFacts({
-                            runtimeId: entry.id,
-                            wallet: entry.wallet,
-                            stateDir: entryStateDir,
-                            pathOrContent,
-                            fromPath: hasPath,
-                            runtimeYamlDir: hasPath ? dirname(pathOrContent) : entry.runtimeYamlDir,
-                        });
+                        const { pathOrContent, fromPath: hasPath, stateDir: entryStateDir } = inputs;
+                        // Local only (files, no network). Read here for the `factsSent` stamp on this start.
+                        const factsPlan = await planInstanceFacts(inputs);
                         const handle = await run(pathOrContent, {
                             fromPath: hasPath,
                             stateDir: entryStateDir,
@@ -792,7 +790,7 @@ const senpiRuntimePlugin = {
                         runtimeHandles.set(entry.id, handle);
                         started.push(entry.id);
                         if (factsPlan)
-                            factsPlans.push(factsPlan);
+                            factsRuntimeIds.push(entry.id);
                         // ── supervised scanner mount (additive; guarded) ──────────────────
                         // Boot path: used for runtimes already present in the registry at
                         // startup. A runtime installed live, after the API is listening,
@@ -885,8 +883,12 @@ const senpiRuntimePlugin = {
                     throw err;
                 }
                 pluginLogger.info(`[senpi-runtime] Started ${started.length} runtime${started.length === 1 ? "" : "s"}`);
-                // Detached: the facts send never holds boot or trading. One line per instance.
-                void sendBootFacts(factsPlans, bootStrategyIds).catch((err) => {
+                // Detached: the facts send never holds boot or trading. One line per instance, one instance at
+                // a time, each planned again when its turn comes under the per-runtime facts lock.
+                void (async () => {
+                    for (const runtimeId of factsRuntimeIds)
+                        await queueFactsSend(runtimeId, bootStrategyIds);
+                })().catch((err) => {
                     factsLogger.warn("strategy facts send crashed", err);
                 });
                 // ── HTTP API ──────────────────────────────────────────────────────
@@ -1628,8 +1630,27 @@ const senpiRuntimePlugin = {
             else
                 respond(false, undefined, result.error);
         }, { scope: "operator.write" });
-        // ── StrategyFacts at boot (ticket 125) ─────────────────────────────────
-        /** The boot plan for one instance, or null (logged once as `failed`) when it cannot be made. */
+        // ── StrategyFacts send ─────────────────────────────────────────────────
+        /**
+         * The facts plan inputs for one registry entry, which are also the recipe and state dir boot
+         * starts it with. Null when the entry holds both or neither of a recipe path and recipe content.
+         */
+        function factsPlanInputs(entry) {
+            const hasPath = typeof entry.runtimeYamlPath === "string" && entry.runtimeYamlPath.length > 0;
+            const hasContent = typeof entry.runtimeYamlContent === "string";
+            if (hasPath === hasContent)
+                return null;
+            const pathOrContent = entry.runtimeYamlPath ?? entry.runtimeYamlContent;
+            return {
+                runtimeId: entry.id,
+                wallet: entry.wallet,
+                stateDir: buildRuntimeStateDir(baseStateDir, entry.id, entry.wallet ?? ""),
+                pathOrContent,
+                fromPath: hasPath,
+                runtimeYamlDir: hasPath ? dirname(pathOrContent) : entry.runtimeYamlDir,
+            };
+        }
+        /** The facts plan for one instance, or null (logged once as `failed`) when it cannot be made. */
         async function planInstanceFacts(input) {
             try {
                 const config = await loadRuntimeConfig(input.pathOrContent, { fromPath: input.fromPath });
@@ -1696,6 +1717,43 @@ const senpiRuntimePlugin = {
                     await session.client.disconnect().catch(() => { });
             }
         }
+        /**
+         * Send one runtime's facts under `factsSendLock`. The plan is made from the registry entry and
+         * the state file as they are when the send runs, so the last send for a runtime carries its
+         * current recipe. A runtime no longer in the registry, or whose entry cannot be planned, gets
+         * no send. An unchanged plan makes no call.
+         *
+         * `strategyIds` is the boot's one batched status read (null when that read failed). Without it,
+         * the strategy id is read for this one wallet; a failed read logs its reason and sends nothing.
+         */
+        function queueFactsSend(runtimeId, strategyIds) {
+            return factsSendLock.withKeyLock(runtimeId, async () => {
+                const { readRegistry } = await import("./runtime/strategy-registry.js");
+                const entry = (await readRegistry(baseStateDir)).runtimes.find((e) => e.id === runtimeId);
+                const inputs = entry ? factsPlanInputs(entry) : null;
+                if (!inputs)
+                    return;
+                const plan = await planInstanceFacts(inputs);
+                if (!plan)
+                    return;
+                let ids = strategyIds ?? null;
+                if (strategyIds === undefined && !plan.unchanged) {
+                    const read = await readBootWalletStatuses([plan.wallet.trim().toLowerCase()], (wallets, signal) => withSenpiClient((client) => client.listStrategies({ strategyAddresses: wallets }, { signal })));
+                    if (!read.ok) {
+                        factsLogger.warn("strategy facts failed: could not read the strategy id; retrying next boot", undefined, {
+                            runtimeId: plan.runtimeId,
+                            wallet: plan.wallet,
+                            hash: plan.hash.slice(0, 12),
+                            reason: read.reason,
+                            detail: read.message,
+                        });
+                        return;
+                    }
+                    ids = read.strategyIds;
+                }
+                await sendBootFacts([plan], ids);
+            });
+        }
         /** One connected SenpiClient per job; always disconnected, even on failure. */
         async function withSenpiClient(fn) {
             const client = mcpTransport ? new SenpiClient(mcpTransport) : new SenpiClient({ apiKey });
@@ -1908,6 +1966,13 @@ const senpiRuntimePlugin = {
                         ...(info.slots !== undefined ? { slots: info.slots } : {}),
                     });
                 });
+                // The apply swaps the recipe with no boot, so this send moves the backend's facts (what the
+                // app shows) to the new recipe before the next boot. Detached: the apply has landed and must
+                // not wait on, or fail over, the send. The send plans from the registry entry the apply has
+                // written, and takes the wallet from that entry or its recipe.
+                void queueFactsSend(info.runtimeId).catch((err) => {
+                    factsLogger.warn("strategy facts send crashed", err);
+                });
             },
         });
         registerDeployGatewayMethods(api, {
@@ -2055,6 +2120,7 @@ const senpiRuntimePlugin = {
             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 });
+            // `exchangeStop` is derived from the state on each response and is not persisted.
             const matches = [];
             for (const [id, handle] of runtimeHandles) {
                 if (runtimeId && id !== runtimeId)
@@ -2065,12 +2131,18 @@ const senpiRuntimePlugin = {
                     if (address) {
                         const state = handle.dsl.getPositionState(address, asset);
                         if (state)
-                            matches.push({ runtimeId: id, address, state });
+                            matches.push({ runtimeId: id, address, state, exchangeStop: exchangeStopClass(state) });
                     }
                     else {
                         const found = handle.dsl.findPositionByAsset(asset);
-                        if (found)
-                            matches.push({ runtimeId: id, address: found.address, state: found.state });
+                        if (found) {
+                            matches.push({
+                                runtimeId: id,
+                                address: found.address,
+                                state: found.state,
+                                exchangeStop: exchangeStopClass(found.state),
+                            });
+                        }
                     }
                 }
                 catch (err) {