@synergenius/flow-weaver-pack-weaver 0.9.59 → 0.9.77

package/src/ui/swarm-controls.tsx

@@ -0,0 +1,260 @@
+/**
+ * SwarmControls — control bar for the swarm: start/pause/stop, status badge, active bots count.
+ * Runs in the pack sandbox — uses CommonJS require, React.createElement throughout.
+ */
+const React = require('react');
+const { useState, useCallback } = React;
+const {
+  Flex, Button, Typography, IconButton, StatusIcon, toast, usePackWorkspace,
+} = require('@fw/plugin-ui-kit');
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+interface InstanceInfo {
+  instanceId: string;
+  profileId: string;
+  status: 'idle' | 'executing' | 'paused' | 'stopped';
+  currentTaskId?: string;
+}
+
+interface SwarmStatus {
+  status: 'idle' | 'running' | 'paused' | 'stopping';
+  instances: Record<string, InstanceInfo>;
+  maxConcurrent: number;
+  tasksCompleted: number;
+  tasksFailed: number;
+  totalTokensUsed: number;
+  totalCost: number;
+  startedAt?: string;
+}
+
+interface SwarmControlsProps {
+  swarmStatus: SwarmStatus | null;
+  onRefresh: () => void;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function swarmStatusToIconStatus(status: string): 'pending' | 'running' | 'completed' | 'failed' {
+  switch (status) {
+    case 'running': return 'running';
+    case 'paused': return 'pending';
+    case 'stopping': return 'failed';
+    case 'idle':
+    default: return 'completed';
+  }
+}
+
+function statusLabel(status: string): string {
+  switch (status) {
+    case 'running': return 'Running';
+    case 'paused': return 'Paused';
+    case 'stopping': return 'Stopping';
+    case 'idle':
+    default: return 'Idle';
+  }
+}
+
+function countActiveInstances(instances: Record<string, InstanceInfo>): { active: number; total: number } {
+  const entries = Object.values(instances);
+  const active = entries.filter(i => i.status === 'executing').length;
+  return { active, total: entries.length };
+}
+
+// ---------------------------------------------------------------------------
+// Component
+// ---------------------------------------------------------------------------
+
+function SwarmControls({ swarmStatus, onRefresh }: SwarmControlsProps) {
+  const ctx = usePackWorkspace();
+  const [starting, setStarting] = useState(false);
+  const [pausing, setPausing] = useState(false);
+  const [stopping, setStopping] = useState(false);
+
+  const status = swarmStatus?.status ?? 'idle';
+  const instances = swarmStatus?.instances ?? {};
+  const { active, total } = countActiveInstances(instances);
+
+  const isIdle = status === 'idle';
+  const isRunning = status === 'running';
+  const isPaused = status === 'paused';
+  const isStopping = status === 'stopping';
+
+  // --- Actions ---
+
+  const handleStart = useCallback(async () => {
+    setStarting(true);
+    try {
+      const result = await ctx.callTool('fw_weaver_swarm_start', {});
+      const data = result as Record<string, unknown> | null;
+      if (data?.error) {
+        toast(String(data.error), { type: 'error' });
+      } else {
+        toast('Swarm started', { type: 'success' });
+      }
+      onRefresh();
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : 'Failed to start swarm';
+      toast(msg, { type: 'error' });
+    }
+    setStarting(false);
+  }, [ctx, onRefresh]);
+
+  const handlePause = useCallback(async () => {
+    setPausing(true);
+    try {
+      const result = await ctx.callTool('fw_weaver_swarm_pause', {});
+      const data = result as Record<string, unknown> | null;
+      if (data?.error) {
+        toast(String(data.error), { type: 'error' });
+      } else {
+        toast('Swarm paused', { type: 'info' });
+      }
+      onRefresh();
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : 'Failed to pause swarm';
+      toast(msg, { type: 'error' });
+    }
+    setPausing(false);
+  }, [ctx, onRefresh]);
+
+  const handleResume = useCallback(async () => {
+    setStarting(true);
+    try {
+      const result = await ctx.callTool('fw_weaver_swarm_start', {});
+      const data = result as Record<string, unknown> | null;
+      if (data?.error) {
+        toast(String(data.error), { type: 'error' });
+      } else {
+        toast('Swarm resumed', { type: 'success' });
+      }
+      onRefresh();
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : 'Failed to resume swarm';
+      toast(msg, { type: 'error' });
+    }
+    setStarting(false);
+  }, [ctx, onRefresh]);
+
+  const handleStop = useCallback(async () => {
+    setStopping(true);
+    const ok = await ctx.confirm('This will stop all running instances and abort active tasks.', {
+      title: 'Stop Swarm',
+      confirmLabel: 'Stop',
+      state: 'danger',
+    });
+    if (!ok) { setStopping(false); return; }
+    try {
+      const result = await ctx.callTool('fw_weaver_swarm_stop', {});
+      const data = result as Record<string, unknown> | null;
+      if (data?.error) {
+        toast(String(data.error), { type: 'error' });
+      } else {
+        toast('Swarm stopped', { type: 'info' });
+      }
+      onRefresh();
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : 'Failed to stop swarm';
+      toast(msg, { type: 'error' });
+    }
+    setStopping(false);
+  }, [ctx, onRefresh]);
+
+  // --- Render ---
+
+  const anyLoading = starting || pausing || stopping;
+
+  return React.createElement(Flex, {
+    variant: 'row-center-space-between-nowrap-10',
+    style: {
+      padding: '8px 16px',
+      borderBottom: '1px solid var(--color-border-default)',
+      flexShrink: 0,
+      backgroundColor: isRunning
+        ? 'var(--color-brand-main-alpha-10)'
+        : isPaused
+          ? 'var(--color-status-caution-alpha-10)'
+          : 'transparent',
+    },
+  },
+    // Left: status icon + label
+    React.createElement(Flex, { variant: 'row-center-start-nowrap-8', style: { flexShrink: 0 } },
+      React.createElement(StatusIcon, {
+        status: swarmStatusToIconStatus(status),
+        size: 'sm',
+      }),
+      React.createElement(Typography, {
+        variant: 'caption-bold',
+      }, statusLabel(status)),
+    ),
+
+    // Center: bot count + stats
+    React.createElement(Flex, {
+      variant: 'row-center-start-nowrap-12',
+      style: { flex: 1 },
+    },
+      total > 0 && React.createElement(Typography, {
+        variant: 'caption-regular',
+        color: 'color-text-medium',
+      }, `${active}/${total} bots active`),
+      swarmStatus && swarmStatus.tasksCompleted > 0 && React.createElement(Typography, {
+        variant: 'caption-regular',
+        color: 'color-text-subtle',
+      }, `${swarmStatus.tasksCompleted} done`),
+      swarmStatus && swarmStatus.tasksFailed > 0 && React.createElement(Typography, {
+        variant: 'caption-regular',
+        color: 'color-status-negative',
+      }, `${swarmStatus.tasksFailed} failed`),
+    ),
+
+    // Right: action buttons
+    React.createElement(Flex, { variant: 'row-center-start-nowrap-4', style: { flexShrink: 0 } },
+      // Start / Resume button
+      (isIdle || isPaused) && React.createElement(Button, {
+        size: 'xs',
+        variant: 'outlined',
+        color: 'primary',
+        onClick: isPaused ? handleResume : handleStart,
+        loading: starting,
+        disabled: anyLoading,
+      }, isPaused ? 'Resume' : 'Start'),
+
+      // Pause button (only when running)
+      isRunning && React.createElement(Button, {
+        size: 'xs',
+        variant: 'outlined',
+        color: 'warning',
+        onClick: handlePause,
+        loading: pausing,
+        disabled: anyLoading,
+      }, 'Pause'),
+
+      // Stop button (when running or paused)
+      (isRunning || isPaused) && React.createElement(Button, {
+        size: 'xs',
+        variant: 'outlined',
+        color: 'danger',
+        onClick: handleStop,
+        loading: stopping,
+        disabled: anyLoading || isStopping,
+      }, 'Stop'),
+
+      // Refresh button (always available)
+      React.createElement(IconButton, {
+        icon: 'reset',
+        size: 'xs',
+        variant: 'outlined',
+        onClick: onRefresh,
+        disabled: anyLoading,
+      }),
+    ),
+  );
+}
+
+export { SwarmControls };
+export default SwarmControls;
+module.exports = SwarmControls;