@nextclaw/ui 0.13.8-beta.0 → 0.13.9

package/src/features/system-status/managers/system-status.manager.bootstrap-polling.test.ts

@@ -1,17 +1,77 @@
-import { beforeEach, describe, expect, it } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { systemStatusManager } from './system-status.manager';
-import { useSystemStatusStore } from '@/features/system-status/stores/system-status.store';
+import { appQueryClient } from '@/app-query-client';
+import type { BootstrapStatusView } from '@/shared/lib/api';
+
+const initializingBootstrapStatus: BootstrapStatusView = {
+  phase: 'shell-ready',
+  ncpAgent: {
+    state: 'running',
+  },
+  extensionLoading: {
+    state: 'pending',
+    loadedExtensionCount: 0,
+    totalExtensionCount: 0,
+  },
+  channels: {
+    state: 'pending',
+    enabled: [],
+  },
+  remote: {
+    state: 'pending',
+  },
+};
+
+const errorBootstrapStatus: BootstrapStatusView = {
+  phase: 'error',
+  ncpAgent: {
+    state: 'error',
+    error: 'startup failed',
+  },
+  extensionLoading: {
+    state: 'pending',
+    loadedExtensionCount: 0,
+    totalExtensionCount: 0,
+  },
+  channels: {
+    state: 'pending',
+    enabled: [],
+  },
+  remote: {
+    state: 'pending',
+  },
+  lastError: 'startup failed',
+};
+
+const readyBootstrapStatus: BootstrapStatusView = {
+  phase: 'ready',
+  ncpAgent: {
+    state: 'ready',
+  },
+  extensionLoading: {
+    state: 'ready',
+    loadedExtensionCount: 1,
+    totalExtensionCount: 1,
+  },
+  channels: {
+    state: 'ready',
+    enabled: [],
+  },
+  remote: {
+    state: 'disabled',
+  },
+};
 
 describe('getRuntimeBootstrapPollInterval', () => {
   beforeEach(() => {
-    useSystemStatusStore.setState({
-      state: {
-        ...useSystemStatusStore.getState().state,
-        lifecyclePhase: 'cold-starting',
-        hasReachedReady: false,
-        activeSystemAction: null,
-      },
-    });
+    vi.useFakeTimers();
+    systemStatusManager.resetForTests();
+  });
+
+  afterEach(() => {
+    systemStatusManager.resetForTests();
+    vi.restoreAllMocks();
+    vi.useRealTimers();
   });
 
   it('keeps polling while bootstrap status is missing', () => {
@@ -22,115 +82,92 @@ describe('getRuntimeBootstrapPollInterval', () => {
 
   it('keeps polling while ncp agent is still initializing', () => {
     expect(
-      systemStatusManager.getRuntimeBootstrapPollInterval({
-        phase: 'shell-ready',
-        ncpAgent: {
-          state: 'running',
-        },
-        extensionLoading: {
-          state: 'pending',
-          loadedExtensionCount: 0,
-          totalExtensionCount: 0,
-        },
-        channels: {
-          state: 'pending',
-          enabled: [],
-        },
-        remote: {
-          state: 'pending',
-        },
-      })
+      systemStatusManager.getRuntimeBootstrapPollInterval(
+        initializingBootstrapStatus
+      )
     ).toBe(1000);
   });
 
-  it('continues polling even when bootstrap status reports an ncp agent error', () => {
+  it('starts hot backoff when bootstrap status reports an ncp agent error', () => {
+    systemStatusManager.reportBootstrapStatus(errorBootstrapStatus);
+
     expect(
-      systemStatusManager.getRuntimeBootstrapPollInterval({
-        phase: 'error',
-        ncpAgent: {
-          state: 'error',
-          error: 'startup failed',
-        },
-        extensionLoading: {
-          state: 'pending',
-          loadedExtensionCount: 0,
-          totalExtensionCount: 0,
-        },
-        channels: {
-          state: 'pending',
-          enabled: [],
-        },
-        remote: {
-          state: 'pending',
-        },
-        lastError: 'startup failed',
-      })
-    ).toBe(2000);
+      systemStatusManager.getRuntimeBootstrapPollInterval(errorBootstrapStatus)
+    ).toBe(500);
   });
 
   it('stops polling once the ncp agent is ready', () => {
     expect(
-      systemStatusManager.getRuntimeBootstrapPollInterval({
-        phase: 'ready',
-        ncpAgent: {
-          state: 'ready',
-        },
-        extensionLoading: {
-          state: 'ready',
-          loadedExtensionCount: 1,
-          totalExtensionCount: 1,
-        },
-        channels: {
-          state: 'ready',
-          enabled: [],
-        },
-        remote: {
-          state: 'disabled',
-        },
-      })
+      systemStatusManager.getRuntimeBootstrapPollInterval(readyBootstrapStatus)
     ).toBe(false);
   });
 
   it('keeps polling while the runtime is recovering even if the last bootstrap status was ready', () => {
-    useSystemStatusStore.setState({
-      state: {
-        ...useSystemStatusStore.getState().state,
-        lifecyclePhase: 'recovering',
-        hasReachedReady: true,
-        lastReadyAt: Date.now(),
-        recoveryStartedAt: Date.now(),
-      },
-    });
+    systemStatusManager.reportBootstrapStatus(readyBootstrapStatus);
+    systemStatusManager.handleConnectionInterrupted('websocket error');
 
     expect(
-      systemStatusManager.getRuntimeBootstrapPollInterval({
-        phase: 'ready',
-        ncpAgent: {
-          state: 'ready',
-        },
-        extensionLoading: {
-          state: 'ready',
-          loadedExtensionCount: 1,
-          totalExtensionCount: 1,
-        },
-        channels: {
-          state: 'ready',
-          enabled: [],
-        },
-        remote: {
-          state: 'disabled',
-        },
-      })
-    ).toBe(1000);
+      systemStatusManager.getRuntimeBootstrapPollInterval(readyBootstrapStatus)
+    ).toBe(500);
   });
 
   it('backs off polling after transport failures', () => {
+    systemStatusManager.reportBootstrapQueryError(new Error('Failed to fetch'));
+    expect(systemStatusManager.getRuntimeBootstrapPollInterval(undefined)).toBe(
+      500
+    );
+
+    systemStatusManager.reportBootstrapQueryError(new Error('Failed to fetch'));
     expect(
-      systemStatusManager.getRuntimeBootstrapPollInterval(undefined, 1)
-    ).toBe(2000);
+      systemStatusManager.getRuntimeBootstrapPollInterval(undefined)
+    ).toBe(1000);
+
+    systemStatusManager.reportBootstrapQueryError(new Error('Failed to fetch'));
     expect(
-      systemStatusManager.getRuntimeBootstrapPollInterval(undefined, 3)
-    ).toBe(5000);
+      systemStatusManager.getRuntimeBootstrapPollInterval(undefined)
+    ).toBe(2000);
+  });
+
+  it('slows down after the hot recovery and long failure windows', async () => {
+    systemStatusManager.reportBootstrapQueryError(new Error('Failed to fetch'));
+
+    await vi.advanceTimersByTimeAsync(31_000);
+    expect(systemStatusManager.getRuntimeBootstrapPollInterval(undefined)).toBe(
+      10_000
+    );
+
+    systemStatusManager.reportBootstrapQueryError(new Error('Failed to fetch'));
+    systemStatusManager.reportBootstrapQueryError(new Error('Failed to fetch'));
+    expect(systemStatusManager.getRuntimeBootstrapPollInterval(undefined)).toBe(
+      30_000
+    );
+
+    await vi.advanceTimersByTimeAsync(5 * 60_000);
+    expect(systemStatusManager.getRuntimeBootstrapPollInterval(undefined)).toBe(
+      60_000
+    );
   });
 
+  it('lets manual runtime probe trigger one immediate interval after readiness stopped polling', async () => {
+    const refetchQueriesSpy = vi
+      .spyOn(appQueryClient, 'refetchQueries')
+      .mockResolvedValue(undefined as never);
+
+    systemStatusManager.reportBootstrapStatus(readyBootstrapStatus);
+    expect(
+      systemStatusManager.getRuntimeBootstrapPollInterval(readyBootstrapStatus)
+    ).toBe(false);
+
+    systemStatusManager.requestRuntimeBootstrapProbeNow();
+
+    expect(refetchQueriesSpy).toHaveBeenCalledWith({
+      queryKey: ['runtime-bootstrap-status'],
+    });
+    expect(
+      systemStatusManager.getRuntimeBootstrapPollInterval(readyBootstrapStatus)
+    ).toBe(0);
+    expect(
+      systemStatusManager.getRuntimeBootstrapPollInterval(readyBootstrapStatus)
+    ).toBe(false);
+  });
 });

package/src/features/system-status/managers/system-status.manager.ts

@@ -22,12 +22,18 @@ import {
   useSystemStatusStore,
 } from '@/features/system-status/stores/system-status.store';
 import { isTransientRuntimeConnectionErrorMessage } from '@/shared/lib/transport';
+import { AdaptiveCadence } from '@/shared/lib/cadence';
 
 const RECOVERY_TIMEOUT_MS = 30_000;
-const RUNTIME_BOOTSTRAP_PROBE_POLICY = {
-  activePollIntervalMs: 1_000,
-  errorPollIntervalMs: 2_000,
-  maxErrorPollIntervalMs: 5_000,
+const RUNTIME_BOOTSTRAP_PROBE_CADENCE = {
+  idleDelayMs: 1_000,
+  manualTriggerDelayMs: 0,
+  successDelayMs: false,
+  stages: [
+    { untilElapsedMs: 30_000, delaysMs: [500, 1_000, 2_000, 4_000, 5_000] },
+    { untilElapsedMs: 5 * 60_000, delaysMs: [10_000, 15_000, 30_000] },
+    { delaysMs: [60_000] },
+  ],
 } as const;
 
 function getErrorMessage(error: unknown): string {
@@ -61,32 +67,29 @@ function resolveActionHelp(action: RuntimeControlAction): string {
 
 export class SystemStatusManager {
   private recoveryTimeoutId: number | null = null;
+  private readonly runtimeBootstrapProbeCadence = new AdaptiveCadence(
+    RUNTIME_BOOTSTRAP_PROBE_CADENCE,
+  );
 
   getRuntimeBootstrapPollInterval = (
     status: BootstrapStatusView | null | undefined,
-    fetchFailureCount = 0
   ): number | false => {
     const { lifecyclePhase, activeSystemAction } = this.getState();
-    if (fetchFailureCount > 0) {
-      return Math.min(
-        RUNTIME_BOOTSTRAP_PROBE_POLICY.maxErrorPollIntervalMs,
-        RUNTIME_BOOTSTRAP_PROBE_POLICY.errorPollIntervalMs * fetchFailureCount
-      );
-    }
-    if (
+    const isRecovering =
       lifecyclePhase === 'recovering' ||
       lifecyclePhase === 'stalled' ||
-      activeSystemAction?.lifecycle === 'recovering'
-    ) {
-      return RUNTIME_BOOTSTRAP_PROBE_POLICY.activePollIntervalMs;
+      activeSystemAction?.lifecycle === 'recovering';
+    if (this.runtimeBootstrapProbeCadence.hasManualTrigger()) {
+      return this.runtimeBootstrapProbeCadence.getNextDelay({
+        consumeManualTrigger: true,
+      });
     }
-    if (status?.ncpAgent.state === 'ready') {
+    if (!isRecovering && status?.ncpAgent.state === 'ready') {
       return false;
     }
-    if (status?.ncpAgent.state === 'error' || status?.phase === 'error') {
-      return RUNTIME_BOOTSTRAP_PROBE_POLICY.errorPollIntervalMs;
-    }
-    return RUNTIME_BOOTSTRAP_PROBE_POLICY.activePollIntervalMs;
+    return this.runtimeBootstrapProbeCadence.getNextDelay({
+      consumeManualTrigger: true,
+    });
   };
 
   getRuntimeControl = async (): Promise<RuntimeControlView> => {
@@ -137,6 +140,7 @@ export class SystemStatusManager {
     }
     const state = this.getState();
     if (!state.hasReachedReady) {
+      this.runtimeBootstrapProbeCadence.recordFailure();
       this.patchState({
         lastTransportError: message,
       });
@@ -150,6 +154,7 @@ export class SystemStatusManager {
     const state = this.getState();
     const normalizedMessage = message?.trim() || null;
     if (!state.hasReachedReady) {
+      this.runtimeBootstrapProbeCadence.recordFailure();
       if (normalizedMessage) {
         this.patchState({
           lastTransportError: normalizedMessage,
@@ -215,6 +220,7 @@ export class SystemStatusManager {
           message: t('runtimeControlRecoveringHelp'),
         },
       });
+      this.runtimeBootstrapProbeCadence.requestManualTrigger();
 
       const recoveredView = await this.waitForRecovery();
       this.syncRuntimeControlQueryCache(recoveredView);
@@ -240,8 +246,16 @@ export class SystemStatusManager {
 
   getStatusView = () => toSystemStatusView(this.getState());
 
+  requestRuntimeBootstrapProbeNow = (): void => {
+    this.runtimeBootstrapProbeCadence.requestManualTrigger();
+    void appQueryClient.refetchQueries({
+      queryKey: ['runtime-bootstrap-status'],
+    });
+  };
+
   resetForTests = (): void => {
     this.clearRecoveryTimeout();
+    this.runtimeBootstrapProbeCadence.reset();
     useSystemStatusStore.setState({
       state: initialSystemStatusState,
     });
@@ -258,6 +272,7 @@ export class SystemStatusManager {
   private transitionToColdStarting = (
     bootstrapStatus: BootstrapStatusView
   ): void => {
+    this.runtimeBootstrapProbeCadence.recordFailure();
     this.clearRecoveryTimeout();
     this.patchState({
       lifecyclePhase: 'cold-starting',
@@ -271,6 +286,7 @@ export class SystemStatusManager {
     errorMessage: string | null,
     bootstrapStatus?: BootstrapStatusView
   ): void => {
+    this.runtimeBootstrapProbeCadence.recordFailure();
     this.clearRecoveryTimeout();
     this.patchState({
       lifecyclePhase: 'startup-failed',
@@ -284,6 +300,7 @@ export class SystemStatusManager {
     errorMessage: string | null,
     bootstrapStatus?: BootstrapStatusView
   ): void => {
+    this.runtimeBootstrapProbeCadence.recordFailure();
     const state = this.getState();
     if (!state.hasReachedReady) {
       this.patchState({
@@ -321,6 +338,7 @@ export class SystemStatusManager {
   private transitionToReady = (
     bootstrapStatus: BootstrapStatusView | null
   ): void => {
+    this.runtimeBootstrapProbeCadence.recordSuccess();
     const state = this.getState();
     const shouldRefreshQueries =
       state.lifecyclePhase === 'recovering' || state.lifecyclePhase === 'stalled';

package/src/shared/components/cron-config.tsx

@@ -7,7 +7,6 @@ import { Input } from '@/shared/components/ui/input';
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/shared/components/ui/select';
 import { Card, CardContent } from '@/shared/components/ui/card';
 import {
-  describeCronDelivery,
   describeCronSchedule,
   describeCronSession,
   formatCronDate,
@@ -26,9 +25,7 @@ function matchQuery(job: CronJobView, query: string): boolean {
     job.id,
     job.name,
     job.payload.message,
-    job.payload.sessionId ?? '',
-    job.payload.channel ?? '',
-    job.payload.to ?? ''
+    job.payload.sessionId ?? ''
   ].join(' ').toLowerCase();
   return haystack.includes(q);
 }
@@ -64,7 +61,6 @@ function CronJobCard(props: {
             <div className="mt-2 text-xs text-gray-500">{t('cronScheduleLabel')}: {describeCronSchedule(job)}</div>
             <div className="mt-2 whitespace-pre-wrap break-words text-sm text-gray-700">{job.payload.message}</div>
             <div className="mt-2 text-xs text-gray-500">{t('cronSessionLabel')}: {describeCronSession(job)}</div>
-            <div className="mt-2 text-xs text-gray-500">{t('cronDeliverTo')}: {describeCronDelivery(job)}</div>
           </div>
           <div className="min-w-[220px] space-y-2 text-xs text-gray-500">
             <div><span className="font-medium text-gray-700">{t('cronNextRun')}:</span> {formatCronDate(job.state.nextRunAt)}</div>

package/src/shared/lib/api/types.ts

@@ -402,10 +402,6 @@ export type CronPayloadView = {
   message: string;
   agentId?: string | null;
   sessionId?: string | null;
-  deliver?: boolean;
-  channel?: string | null;
-  to?: string | null;
-  accountId?: string | null;
 };
 
 export type CronJobStateView = {

package/src/shared/lib/cadence/index.ts

@@ -0,0 +1,7 @@
+export {
+  AdaptiveCadence,
+  type AdaptiveCadenceDelayOptions,
+  type AdaptiveCadenceOptions,
+  type AdaptiveCadenceSnapshot,
+  type AdaptiveCadenceStage,
+} from './services/adaptive-cadence.service';

package/src/shared/lib/cadence/services/adaptive-cadence.service.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it } from 'vitest';
+import { AdaptiveCadence } from './adaptive-cadence.service';
+
+function createClock(initialNow = 0) {
+  let now = initialNow;
+  return {
+    clock: () => now,
+    advance: (ms: number) => {
+      now += ms;
+    },
+  };
+}
+
+function createCadence(clock: () => number): AdaptiveCadence {
+  return new AdaptiveCadence({
+    idleDelayMs: 1000,
+    manualTriggerDelayMs: 0,
+    successDelayMs: false,
+    stages: [
+      { untilElapsedMs: 30_000, delaysMs: [500, 1000, 2000, 4000, 5000] },
+      { untilElapsedMs: 5 * 60_000, delaysMs: [10_000, 15_000, 30_000] },
+      { delaysMs: [60_000] },
+    ],
+    clock,
+  });
+}
+
+describe('AdaptiveCadence', () => {
+  it('uses idle delay before the first failure', () => {
+    const { clock } = createClock();
+    const cadence = createCadence(clock);
+
+    expect(cadence.getNextDelay()).toBe(1000);
+  });
+
+  it('backs off inside the hot recovery stage', () => {
+    const { clock } = createClock();
+    const cadence = createCadence(clock);
+
+    cadence.recordFailure();
+    expect(cadence.getNextDelay()).toBe(500);
+    cadence.recordFailure();
+    expect(cadence.getNextDelay()).toBe(1000);
+    cadence.recordFailure();
+    expect(cadence.getNextDelay()).toBe(2000);
+    cadence.recordFailure();
+    expect(cadence.getNextDelay()).toBe(4000);
+    cadence.recordFailure();
+    expect(cadence.getNextDelay()).toBe(5000);
+    cadence.recordFailure();
+    expect(cadence.getNextDelay()).toBe(5000);
+  });
+
+  it('moves to slower stages as the same failure window ages', () => {
+    const { advance, clock } = createClock();
+    const cadence = createCadence(clock);
+
+    cadence.recordFailure();
+    advance(31_000);
+    expect(cadence.getNextDelay()).toBe(10_000);
+
+    cadence.recordFailure();
+    cadence.recordFailure();
+    expect(cadence.getNextDelay()).toBe(30_000);
+
+    advance(5 * 60_000);
+    expect(cadence.getNextDelay()).toBe(60_000);
+  });
+
+  it('stops after success and starts a fresh window after the next failure', () => {
+    const { clock } = createClock();
+    const cadence = createCadence(clock);
+
+    cadence.recordFailure();
+    cadence.recordFailure();
+    expect(cadence.getNextDelay()).toBe(1000);
+
+    cadence.recordSuccess();
+    expect(cadence.getNextDelay()).toBe(false);
+
+    cadence.recordFailure();
+    expect(cadence.getNextDelay()).toBe(500);
+  });
+
+  it('supports a one-shot manual trigger delay', () => {
+    const { clock } = createClock();
+    const cadence = createCadence(clock);
+
+    cadence.recordSuccess();
+    cadence.requestManualTrigger();
+
+    expect(cadence.getNextDelay({ consumeManualTrigger: true })).toBe(0);
+    expect(cadence.getNextDelay()).toBe(1000);
+  });
+});

package/src/shared/lib/cadence/services/adaptive-cadence.service.ts

@@ -0,0 +1,120 @@
+export type AdaptiveCadenceStage = {
+  untilElapsedMs?: number;
+  delaysMs: readonly number[];
+};
+
+export type AdaptiveCadenceOptions = {
+  idleDelayMs: number | false;
+  manualTriggerDelayMs: number;
+  successDelayMs: number | false;
+  stages: readonly AdaptiveCadenceStage[];
+  clock?: () => number;
+};
+
+export type AdaptiveCadenceSnapshot = {
+  attempt: number;
+  startedAt: number | null;
+  lastFailureAt: number | null;
+  lastSuccessAt: number | null;
+  manualTriggerPending: boolean;
+  completed: boolean;
+};
+
+export type AdaptiveCadenceDelayOptions = {
+  consumeManualTrigger?: boolean;
+};
+
+function validateStages(stages: readonly AdaptiveCadenceStage[]): void {
+  if (stages.length === 0) {
+    throw new Error('AdaptiveCadence requires at least one stage.');
+  }
+  for (const stage of stages) {
+    if (stage.delaysMs.length === 0) {
+      throw new Error('AdaptiveCadence stage requires at least one delay.');
+    }
+  }
+}
+
+export class AdaptiveCadence {
+  private attempt = 0;
+  private startedAt: number | null = null;
+  private lastFailureAt: number | null = null;
+  private lastSuccessAt: number | null = null;
+  private manualTriggerPending = false;
+  private completed = false;
+  private readonly clock: () => number;
+
+  constructor(private readonly options: AdaptiveCadenceOptions) {
+    validateStages(options.stages);
+    this.clock = options.clock ?? (() => Date.now());
+  }
+
+  recordFailure = (): void => {
+    const now = this.clock();
+    this.completed = false;
+    this.manualTriggerPending = false;
+    this.startedAt = this.startedAt ?? now;
+    this.lastFailureAt = now;
+    this.attempt += 1;
+  };
+
+  recordSuccess = (): void => {
+    this.lastSuccessAt = this.clock();
+    this.attempt = 0;
+    this.startedAt = null;
+    this.lastFailureAt = null;
+    this.manualTriggerPending = false;
+    this.completed = true;
+  };
+
+  reset = (): void => {
+    this.attempt = 0;
+    this.startedAt = null;
+    this.lastFailureAt = null;
+    this.lastSuccessAt = null;
+    this.manualTriggerPending = false;
+    this.completed = false;
+  };
+
+  requestManualTrigger = (): void => {
+    this.completed = false;
+    this.manualTriggerPending = true;
+  };
+
+  hasManualTrigger = (): boolean => this.manualTriggerPending;
+
+  getNextDelay = (
+    delayOptions: AdaptiveCadenceDelayOptions = {},
+  ): number | false => {
+    if (this.manualTriggerPending) {
+      if (delayOptions.consumeManualTrigger) {
+        this.manualTriggerPending = false;
+      }
+      return this.options.manualTriggerDelayMs;
+    }
+    if (this.completed) {
+      return this.options.successDelayMs;
+    }
+    if (this.startedAt === null) {
+      return this.options.idleDelayMs;
+    }
+
+    const stage = this.resolveStage(this.clock() - this.startedAt);
+    return stage.delaysMs[Math.min(this.attempt - 1, stage.delaysMs.length - 1)];
+  };
+
+  getSnapshot = (): AdaptiveCadenceSnapshot => ({
+    attempt: this.attempt,
+    startedAt: this.startedAt,
+    lastFailureAt: this.lastFailureAt,
+    lastSuccessAt: this.lastSuccessAt,
+    manualTriggerPending: this.manualTriggerPending,
+    completed: this.completed,
+  });
+
+  private resolveStage = (elapsedMs: number): AdaptiveCadenceStage =>
+    this.options.stages.find(
+      (stage) =>
+        stage.untilElapsedMs === undefined || elapsedMs < stage.untilElapsedMs,
+    ) ?? this.options.stages[this.options.stages.length - 1];
+}

package/src/shared/lib/cron/cron-job-view.utils.ts

@@ -40,15 +40,6 @@ export function describeCronSchedule(job: CronJobView): string {
   return "-";
 }
 
-export function describeCronDelivery(job: CronJobView): string {
-  if (!job.payload.deliver) {
-    return "-";
-  }
-  const channel = job.payload.channel ?? "-";
-  const target = job.payload.to ?? "-";
-  return `${channel}:${target}`;
-}
-
 export function describeCronSession(job: CronJobView): string {
   return job.payload.sessionId?.trim() || `cron:${job.id}`;
 }