@fiber-pay/runtime 0.1.0-rc.1 → 0.1.0-rc.3

package/README.md

@@ -9,6 +9,31 @@ fiber-pay runtime start --daemon --json
 fiber-pay runtime status --json
 ```
 
+## Single-instance low-CPU defaults
+
+Runtime defaults are tuned for lower idle CPU on one node:
+
+- `channelPollIntervalMs=5000`
+- `invoicePollIntervalMs=3000`
+- `paymentPollIntervalMs=2000`
+- `peerPollIntervalMs=15000`
+- `healthPollIntervalMs=10000`
+- `includeClosedChannels=false`
+- `jobs.schedulerIntervalMs=1000`
+
+If your machine is still busy when idle, start with slower polling explicitly:
+
+```bash
+fiber-pay runtime start \
+  --channel-poll-ms 8000 \
+  --invoice-poll-ms 5000 \
+  --payment-poll-ms 3000 \
+  --peer-poll-ms 20000 \
+  --health-poll-ms 15000 \
+  --include-closed false \
+  --json
+```
+
 ## Manual payment flow (runtime jobs)
 
 前置：`jq`、`curl`、两边 profile 已有资金（示例 `rt-a` / `rt-b`）。

package/dist/index.js

@@ -375,12 +375,12 @@ function computeRetryDelay(retryCount, policy) {
 // src/config.ts
 var defaultRuntimeConfig = {
   fiberRpcUrl: "http://127.0.0.1:8227",
-  channelPollIntervalMs: 3e3,
-  invoicePollIntervalMs: 2e3,
-  paymentPollIntervalMs: 1e3,
-  peerPollIntervalMs: 1e4,
-  healthPollIntervalMs: 5e3,
-  includeClosedChannels: true,
+  channelPollIntervalMs: 5e3,
+  invoicePollIntervalMs: 3e3,
+  paymentPollIntervalMs: 2e3,
+  peerPollIntervalMs: 15e3,
+  healthPollIntervalMs: 1e4,
+  includeClosedChannels: false,
   completedItemTtlSeconds: 86400,
   requestTimeoutMs: 1e4,
   alerts: [{ type: "stdout" }],
@@ -397,28 +397,41 @@ var defaultRuntimeConfig = {
     enabled: true,
     dbPath: resolve(process.cwd(), ".fiber-pay-jobs.db"),
     maxConcurrentJobs: 5,
-    schedulerIntervalMs: 500,
+    schedulerIntervalMs: 1e3,
     retryPolicy: defaultPaymentRetryPolicy
   }
 };
 function createRuntimeConfig(input = {}) {
   const config = {
-    ...defaultRuntimeConfig,
-    ...input,
+    fiberRpcUrl: input.fiberRpcUrl ?? defaultRuntimeConfig.fiberRpcUrl,
+    channelPollIntervalMs: input.channelPollIntervalMs ?? defaultRuntimeConfig.channelPollIntervalMs,
+    invoicePollIntervalMs: input.invoicePollIntervalMs ?? defaultRuntimeConfig.invoicePollIntervalMs,
+    paymentPollIntervalMs: input.paymentPollIntervalMs ?? defaultRuntimeConfig.paymentPollIntervalMs,
+    peerPollIntervalMs: input.peerPollIntervalMs ?? defaultRuntimeConfig.peerPollIntervalMs,
+    healthPollIntervalMs: input.healthPollIntervalMs ?? defaultRuntimeConfig.healthPollIntervalMs,
+    includeClosedChannels: input.includeClosedChannels ?? defaultRuntimeConfig.includeClosedChannels,
+    completedItemTtlSeconds: input.completedItemTtlSeconds ?? defaultRuntimeConfig.completedItemTtlSeconds,
+    requestTimeoutMs: input.requestTimeoutMs ?? defaultRuntimeConfig.requestTimeoutMs,
     proxy: {
-      ...defaultRuntimeConfig.proxy,
-      ...input.proxy
+      enabled: input.proxy?.enabled ?? defaultRuntimeConfig.proxy.enabled,
+      listen: input.proxy?.listen ?? defaultRuntimeConfig.proxy.listen
     },
     storage: {
-      ...defaultRuntimeConfig.storage,
-      ...input.storage
+      stateFilePath: input.storage?.stateFilePath ?? defaultRuntimeConfig.storage.stateFilePath,
+      flushIntervalMs: input.storage?.flushIntervalMs ?? defaultRuntimeConfig.storage.flushIntervalMs,
+      maxAlertHistory: input.storage?.maxAlertHistory ?? defaultRuntimeConfig.storage.maxAlertHistory
     },
     jobs: {
-      ...defaultRuntimeConfig.jobs,
-      ...input.jobs,
+      enabled: input.jobs?.enabled ?? defaultRuntimeConfig.jobs.enabled,
+      dbPath: input.jobs?.dbPath ?? defaultRuntimeConfig.jobs.dbPath,
+      maxConcurrentJobs: input.jobs?.maxConcurrentJobs ?? defaultRuntimeConfig.jobs.maxConcurrentJobs,
+      schedulerIntervalMs: input.jobs?.schedulerIntervalMs ?? defaultRuntimeConfig.jobs.schedulerIntervalMs,
       retryPolicy: {
-        ...defaultRuntimeConfig.jobs.retryPolicy,
-        ...input.jobs?.retryPolicy
+        maxRetries: input.jobs?.retryPolicy?.maxRetries ?? defaultRuntimeConfig.jobs.retryPolicy.maxRetries,
+        baseDelayMs: input.jobs?.retryPolicy?.baseDelayMs ?? defaultRuntimeConfig.jobs.retryPolicy.baseDelayMs,
+        maxDelayMs: input.jobs?.retryPolicy?.maxDelayMs ?? defaultRuntimeConfig.jobs.retryPolicy.maxDelayMs,
+        backoffMultiplier: input.jobs?.retryPolicy?.backoffMultiplier ?? defaultRuntimeConfig.jobs.retryPolicy.backoffMultiplier,
+        jitterMs: input.jobs?.retryPolicy?.jitterMs ?? defaultRuntimeConfig.jobs.retryPolicy.jitterMs
       }
     },
     alerts: input.alerts ?? defaultRuntimeConfig.alerts
@@ -757,6 +770,9 @@ var InvoiceTracker = class extends BaseMonitor {
   async poll() {
     const tracked = this.store.listTrackedInvoices();
     for (const invoice of tracked) {
+      if (isTerminalInvoiceStatusString(invoice.status)) {
+        continue;
+      }
       try {
         const next = await this.client.getInvoice({ payment_hash: invoice.paymentHash });
         const previousStatus = invoice.status;
@@ -813,6 +829,9 @@ var InvoiceTracker = class extends BaseMonitor {
     this.store.pruneCompleted(this.config.completedItemTtlSeconds * 1e3);
   }
 };
+function isTerminalInvoiceStatusString(status) {
+  return status === "Cancelled" || status === "Expired" || status === "Paid";
+}
 
 // src/monitors/payment-tracker.ts
 var PaymentTracker = class extends BaseMonitor {
@@ -833,6 +852,9 @@ var PaymentTracker = class extends BaseMonitor {
   async poll() {
     const tracked = this.store.listTrackedPayments();
     for (const payment of tracked) {
+      if (isTerminalPaymentStatus(payment.status)) {
+        continue;
+      }
       try {
         const next = await this.client.getPayment({ payment_hash: payment.paymentHash });
         const previousStatus = payment.status;
@@ -876,6 +898,9 @@ var PaymentTracker = class extends BaseMonitor {
     this.store.pruneCompleted(this.config.completedItemTtlSeconds * 1e3);
   }
 };
+function isTerminalPaymentStatus(status) {
+  return status === "Success" || status === "Failed";
+}
 
 // src/diff/peer-diff.ts
 function diffPeers(previous, current) {
@@ -1332,6 +1357,7 @@ var RpcMonitorProxy = class {
     if (this.server) {
       return;
     }
+    assertNoProxySelfLoop(this.config.listen, this.config.targetUrl);
     this.server = http2.createServer((req, res) => {
       void this.handleRequest(req, res);
     });
@@ -1422,6 +1448,29 @@ var RpcMonitorProxy = class {
     res.end(responseText);
   }
 };
+function assertNoProxySelfLoop(listen, targetUrl) {
+  const { host, port } = parseListenAddress(listen);
+  let parsed;
+  try {
+    parsed = new URL(targetUrl);
+  } catch {
+    throw new Error(`Invalid proxy targetUrl: ${targetUrl}`);
+  }
+  const targetHost = normalizeHost(parsed.hostname);
+  const listenHost = normalizeHost(host);
+  const targetPort = parsed.port || (parsed.protocol === "https:" ? "443" : "80");
+  if (targetHost === listenHost && targetPort === String(port)) {
+    throw new Error(
+      `Invalid proxy configuration: targetUrl (${targetUrl}) points to proxy listen address (${listen})`
+    );
+  }
+}
+function normalizeHost(host) {
+  if (host === "localhost" || host === "::1") {
+    return "127.0.0.1";
+  }
+  return host;
+}
 
 // src/storage/memory-store.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
@@ -1566,13 +1615,13 @@ var MemoryStore = class {
       ...existing,
       status,
       updatedAt: now,
-      completedAt: isTerminalPaymentStatus(status) ? existing.completedAt ?? now : void 0
+      completedAt: isTerminalPaymentStatus2(status) ? existing.completedAt ?? now : void 0
     } : {
       paymentHash: hash,
       status,
       trackedAt: now,
       updatedAt: now,
-      completedAt: isTerminalPaymentStatus(status) ? now : void 0
+      completedAt: isTerminalPaymentStatus2(status) ? now : void 0
     };
     this.trackedPayments.set(hash, next);
   }
@@ -1607,7 +1656,7 @@ var MemoryStore = class {
 function isTerminalInvoiceStatus(status) {
   return status === "Paid" || status === "Cancelled" || status === "Expired";
 }
-function isTerminalPaymentStatus(status) {
+function isTerminalPaymentStatus2(status) {
   return status === "Success" || status === "Failed";
 }
 
@@ -1899,6 +1948,7 @@ var PATTERNS = [
   // Peer / connectivity
   { pattern: /peer.*offline|peer.*unreachable|peer.*disconnect/i, category: "peer_offline", retryable: true },
   { pattern: /connection.*refused|connection.*reset/i, category: "peer_offline", retryable: true },
+  { pattern: /fetch failed/i, category: "peer_offline", retryable: true },
   { pattern: /peer.*feature not found|waiting for peer to send init message/i, category: "peer_offline", retryable: true },
   { pattern: /channel.*already.*exist|duplicat(e|ed).*channel/i, category: "temporary_failure", retryable: true },
   // Timeout
@@ -2051,8 +2101,12 @@ function transitionJobState(job, machine, event, options) {
 }
 function applyRetryOrFail(job, classifiedError, policy, options) {
   const now = options?.now ?? Date.now();
-  if (shouldRetry(classifiedError, job.retryCount, policy)) {
-    const delay = computeRetryDelay(job.retryCount, policy);
+  const effectivePolicy = {
+    ...policy,
+    maxRetries: job.maxRetries
+  };
+  if (shouldRetry(classifiedError, job.retryCount, effectivePolicy)) {
+    const delay = computeRetryDelay(job.retryCount, effectivePolicy);
     const retryTransition = options?.machine && options.retryEvent ? transitionJobState(job, options.machine, options.retryEvent, { now }) : { ...job, state: "waiting_retry", updatedAt: now };
     return {
       ...retryTransition,
@@ -2237,6 +2291,15 @@ async function* runInvoiceJob(job, rpc, policy, signal) {
     yield current;
   }
   if (current.state === "waiting_retry") {
+    const delay = current.nextRetryAt ? Math.max(0, current.nextRetryAt - Date.now()) : 0;
+    if (delay > 0) {
+      await sleep(delay, signal);
+      if (signal.aborted) {
+        current = transitionJobState(current, invoiceStateMachine, "cancel");
+        yield current;
+        return;
+      }
+    }
     current = transitionJobState(current, invoiceStateMachine, "retry_delay_elapsed", {
       patch: { nextRetryAt: void 0 }
     });
@@ -2443,6 +2506,15 @@ async function* runChannelJob(job, rpc, policy, signal) {
     yield current;
   }
   if (current.state === "waiting_retry") {
+    const delay = current.nextRetryAt ? Math.max(0, current.nextRetryAt - Date.now()) : 0;
+    if (delay > 0) {
+      await sleep(delay, signal);
+      if (signal.aborted) {
+        current = transitionJobState(current, channelStateMachine, "cancel");
+        yield current;
+        return;
+      }
+    }
     current = transitionJobState(current, channelStateMachine, "retry_delay_elapsed", {
       patch: { nextRetryAt: void 0 }
     });
@@ -2656,7 +2728,7 @@ async function* runChannelJob(job, rpc, policy, signal) {
     }
     throw new Error(`Unsupported channel action: ${current.params.action}`);
   } catch (error) {
-    const classified = classifyRpcError(error);
+    const classified = classifyChannelError(error);
     current = applyRetryOrFail(current, classified, policy, {
       machine: channelStateMachine,
       retryEvent: "payment_failed_retryable",
@@ -2665,6 +2737,32 @@ async function* runChannelJob(job, rpc, policy, signal) {
     yield current;
   }
 }
+function classifyChannelError(error) {
+  const base = classifyRpcError(error);
+  if (base.retryable) {
+    return base;
+  }
+  const raw = base.rawError ?? base.message;
+  if (/channel\s+not\s+found|no\s+channel\s+with\s+.*\s+found|no\s+channel\s+.*\s+found/i.test(
+    raw
+  )) {
+    return {
+      ...base,
+      category: "temporary_failure",
+      retryable: true,
+      rawError: raw
+    };
+  }
+  if (/invalid\s+state|negotiatingfunding|cannot\s+.*\s+in\s+.*state/i.test(raw)) {
+    return {
+      ...base,
+      category: "temporary_failure",
+      retryable: true,
+      rawError: raw
+    };
+  }
+  return base;
+}
 async function findTargetChannel(rpc, peerId, channelId) {
   const channels = await rpc.listChannels({
     peer_id: peerId,
@@ -2710,7 +2808,7 @@ var JobManager = class extends EventEmitter {
     this.rpc = rpc;
     this.store = store;
     this.retryPolicy = config.retryPolicy ?? defaultPaymentRetryPolicy;
-    this.schedulerIntervalMs = config.schedulerIntervalMs ?? 500;
+    this.schedulerIntervalMs = config.schedulerIntervalMs ?? 1e3;
     this.maxConcurrentJobs = config.maxConcurrentJobs ?? 5;
   }
   async ensurePayment(params, options = {}) {