@desplega.ai/agent-swarm 1.20.0 → 1.49.0

package/new-ui/src/api/hooks/use-tasks.ts

@@ -0,0 +1,89 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { api } from "../client";
+
+export interface TaskFilters {
+  status?: string;
+  agentId?: string;
+  epicId?: string;
+  scheduleId?: string;
+  search?: string;
+  includeHeartbeat?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export function useTasks(filters?: TaskFilters) {
+  return useQuery({
+    queryKey: ["tasks", filters],
+    queryFn: () => api.fetchTasks(filters),
+    select: (data) => ({ tasks: data.tasks, total: data.total }),
+  });
+}
+
+export function useTask(id: string) {
+  return useQuery({
+    queryKey: ["task", id],
+    queryFn: () => api.fetchTask(id),
+    enabled: !!id,
+  });
+}
+
+export function useTaskSessionLogs(taskId: string) {
+  return useQuery({
+    queryKey: ["task", taskId, "session-logs"],
+    queryFn: () => api.fetchTaskSessionLogs(taskId),
+    enabled: !!taskId,
+    refetchInterval: 5000,
+  });
+}
+
+export function useCreateTask() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data: {
+      task: string;
+      agentId?: string;
+      taskType?: string;
+      tags?: string[];
+      priority?: number;
+      dependsOn?: string[];
+    }) => api.createTask(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["tasks"] });
+    },
+  });
+}
+
+export function useCancelTask() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, reason }: { id: string; reason?: string }) => api.cancelTask(id, reason),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["tasks"] });
+      queryClient.invalidateQueries({ queryKey: ["task"] });
+      queryClient.invalidateQueries({ queryKey: ["stats"] });
+    },
+  });
+}
+
+export function usePauseTask() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (id: string) => api.pauseTask(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["tasks"] });
+      queryClient.invalidateQueries({ queryKey: ["task"] });
+    },
+  });
+}
+
+export function useResumeTask() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (id: string) => api.resumeTask(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["tasks"] });
+      queryClient.invalidateQueries({ queryKey: ["task"] });
+    },
+  });
+}

package/new-ui/src/api/hooks/use-workflows.ts

@@ -0,0 +1,109 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { api } from "../client";
+
+export function useWorkflows() {
+  return useQuery({
+    queryKey: ["workflows"],
+    queryFn: () => api.fetchWorkflows(),
+    select: (data) => data.workflows,
+  });
+}
+
+export function useWorkflow(id: string) {
+  return useQuery({
+    queryKey: ["workflow", id],
+    queryFn: () => api.fetchWorkflow(id),
+    enabled: !!id,
+  });
+}
+
+export function useWorkflowRuns(workflowId: string) {
+  return useQuery({
+    queryKey: ["workflow-runs", workflowId],
+    queryFn: () => api.fetchWorkflowRuns(workflowId),
+    enabled: !!workflowId,
+  });
+}
+
+export function useAllWorkflowRuns() {
+  return useQuery({
+    queryKey: ["workflow-runs-all"],
+    queryFn: () => api.fetchAllWorkflowRuns(),
+  });
+}
+
+export function useWorkflowRun(id: string) {
+  return useQuery({
+    queryKey: ["workflow-run", id],
+    queryFn: () => api.fetchWorkflowRun(id),
+    enabled: !!id,
+  });
+}
+
+export function useUpdateWorkflow() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({
+      id,
+      data,
+    }: {
+      id: string;
+      data: Partial<{ name: string; description: string; enabled: boolean }>;
+    }) => api.updateWorkflow(id, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["workflows"] });
+      queryClient.invalidateQueries({ queryKey: ["workflow"] });
+    },
+  });
+}
+
+export function useDeleteWorkflow() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (id: string) => api.deleteWorkflow(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["workflows"] });
+    },
+  });
+}
+
+export function useTriggerWorkflow() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, triggerData }: { id: string; triggerData?: Record<string, unknown> }) =>
+      api.triggerWorkflow(id, triggerData),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["workflow-runs"] });
+      queryClient.invalidateQueries({ queryKey: ["workflow-runs-all"] });
+    },
+  });
+}
+
+export function useWorkflowVersions(workflowId: string) {
+  return useQuery({
+    queryKey: ["workflow-versions", workflowId],
+    queryFn: () => api.fetchWorkflowVersions(workflowId),
+    enabled: !!workflowId,
+  });
+}
+
+export function useExecutorType(type: string) {
+  return useQuery({
+    queryKey: ["executor-type", type],
+    queryFn: () => api.fetchExecutorType(type),
+    enabled: !!type,
+    staleTime: 60_000, // schemas don't change at runtime
+  });
+}
+
+export function useRetryWorkflowRun() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (id: string) => api.retryWorkflowRun(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["workflow-runs"] });
+      queryClient.invalidateQueries({ queryKey: ["workflow-runs-all"] });
+      queryClient.invalidateQueries({ queryKey: ["workflow-run"] });
+    },
+  });
+}

package/{ui/src/types/api.ts → new-ui/src/api/types.ts}

@@ -1,4 +1,4 @@
-// Backend types (mirrored from cc-orch-mcp/src/types.ts)
+// Backend types (mirrored from agent-swarm backend)
 export type AgentStatus = "idle" | "busy" | "offline";
 export type AgentTaskStatus =
   | "backlog"
@@ -23,6 +23,10 @@ export interface Agent {
   role?: string;
   capabilities?: string[];
   claudeMd?: string;
+  soulMd?: string;
+  identityMd?: string;
+  toolsMd?: string;
+  setupScript?: string;
   maxTasks?: number;
   capacity?: {
     current: number;
@@ -57,6 +61,8 @@ export interface AgentTask {
   failureReason?: string;
   output?: string;
   progress?: string;
+  model?: string;
+  scheduleId?: string;
 }
 
 export interface AgentWithTasks extends Agent {
@@ -141,11 +147,9 @@ export interface DashboardStats {
   };
 }
 
-// Alias for consistency with plan
 export type TaskStatus = AgentTaskStatus;
 export type Stats = DashboardStats;
 
-// API Response wrappers
 export interface AgentsResponse {
   agents: Agent[] | AgentWithTasks[];
 }
@@ -171,7 +175,6 @@ export interface TaskWithLogs extends AgentTask {
   logs: AgentLog[];
 }
 
-// Service Types
 export type ServiceStatus = "starting" | "healthy" | "unhealthy" | "stopped";
 
 export interface Service {
@@ -197,7 +200,6 @@ export interface ServicesResponse {
   services: Service[];
 }
 
-// Session Cost Types (for Usage/Cost Tracking)
 export interface SessionCost {
   id: string;
   sessionId: string;
@@ -219,7 +221,45 @@ export interface SessionCostsResponse {
   costs: SessionCost[];
 }
 
-// Aggregated usage types for UI
+export interface UsageSummaryTotals {
+  totalCostUsd: number;
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  totalCacheReadTokens: number;
+  totalCacheWriteTokens: number;
+  totalDurationMs: number;
+  totalSessions: number;
+  avgCostPerSession: number;
+}
+
+export interface UsageSummaryDailyRow {
+  date: string;
+  costUsd: number;
+  inputTokens: number;
+  outputTokens: number;
+  sessions: number;
+}
+
+export interface UsageSummaryByAgentRow {
+  agentId: string;
+  costUsd: number;
+  inputTokens: number;
+  outputTokens: number;
+  sessions: number;
+  durationMs: number;
+}
+
+export interface UsageSummaryResponse {
+  totals: UsageSummaryTotals;
+  daily: UsageSummaryDailyRow[];
+  byAgent: UsageSummaryByAgentRow[];
+}
+
+export interface DashboardCostResponse {
+  costToday: number;
+  costMtd: number;
+}
+
 export interface UsageStats {
   totalCostUsd: number;
   totalTokens: number;
@@ -247,7 +287,6 @@ export interface AgentUsageSummary {
   sessionCount: number;
 }
 
-// Scheduled Task Types
 export interface ScheduledTask {
   id: string;
   name: string;
@@ -264,6 +303,8 @@ export interface ScheduledTask {
   nextRunAt?: string;
   createdByAgentId?: string;
   timezone: string;
+  model?: string;
+  scheduleType?: "recurring" | "one_time";
   createdAt: string;
   lastUpdatedAt: string;
 }
@@ -272,7 +313,6 @@ export interface ScheduledTasksResponse {
   scheduledTasks: ScheduledTask[];
 }
 
-// Epic Types
 export type EpicStatus = "draft" | "active" | "paused" | "completed" | "cancelled";
 
 export interface Epic {
@@ -292,8 +332,9 @@ export interface Epic {
   planDocPath?: string;
   slackChannelId?: string;
   slackThreadTs?: string;
-  githubRepo?: string;
-  githubMilestone?: string;
+  vcsProvider?: "github" | "gitlab";
+  vcsRepo?: string;
+  vcsMilestone?: string;
   createdAt: string;
   lastUpdatedAt: string;
   startedAt?: string;
@@ -321,3 +362,188 @@ export interface EpicsResponse {
   epics: Epic[];
   total: number;
 }
+
+export type SwarmConfigScope = "global" | "agent" | "repo";
+
+export interface SwarmConfig {
+  id: string;
+  scope: SwarmConfigScope;
+  scopeId: string | null;
+  key: string;
+  value: string;
+  isSecret: boolean;
+  envPath: string | null;
+  description: string | null;
+  createdAt: string;
+  lastUpdatedAt: string;
+}
+
+export interface SwarmConfigsResponse {
+  configs: SwarmConfig[];
+}
+
+export interface SwarmRepo {
+  id: string;
+  url: string;
+  name: string;
+  clonePath: string;
+  defaultBranch: string;
+  autoClone: boolean;
+  createdAt: string;
+  lastUpdatedAt: string;
+}
+
+export interface SwarmReposResponse {
+  repos: SwarmRepo[];
+}
+
+// Workflow types
+
+/** Node types are open strings — new executor types can be added via the registry */
+export type WorkflowNodeType = string;
+
+export interface RetryPolicy {
+  maxRetries: number;
+  strategy: "exponential" | "static" | "linear";
+  baseDelayMs: number;
+  maxDelayMs: number;
+}
+
+export interface StepValidationConfig {
+  executor: string;
+  config: Record<string, unknown>;
+  mustPass: boolean;
+  retry?: RetryPolicy;
+}
+
+export interface WorkflowNode {
+  id: string;
+  type: WorkflowNodeType;
+  label?: string;
+  config: Record<string, unknown>;
+  next?: string | Record<string, string>;
+  validation?: StepValidationConfig;
+  retry?: RetryPolicy;
+}
+
+export interface WorkflowEdge {
+  id: string;
+  source: string;
+  sourcePort: string;
+  target: string;
+}
+
+/** Definition stores only nodes. Edges are auto-generated by the API. */
+export interface WorkflowDefinition {
+  nodes: WorkflowNode[];
+  /** Auto-generated edges returned by GET /api/workflows/:id */
+  edges: WorkflowEdge[];
+}
+
+export interface TriggerConfig {
+  type: "webhook" | "schedule";
+  hmacSecret?: string;
+  hmacHeader?: string;
+  scheduleId?: string;
+}
+
+export interface CooldownConfig {
+  hours?: number;
+  minutes?: number;
+  seconds?: number;
+}
+
+export interface Workflow {
+  id: string;
+  name: string;
+  description?: string;
+  enabled: boolean;
+  definition: WorkflowDefinition;
+  triggers: TriggerConfig[];
+  cooldown?: CooldownConfig;
+  input?: Record<string, string>;
+  createdByAgentId?: string;
+  createdAt: string;
+  lastUpdatedAt: string;
+}
+
+export type WorkflowRunStatus = "running" | "waiting" | "completed" | "failed" | "skipped";
+
+export interface WorkflowRun {
+  id: string;
+  workflowId: string;
+  status: WorkflowRunStatus;
+  triggerData?: unknown;
+  context?: Record<string, unknown>;
+  error?: string;
+  startedAt: string;
+  lastUpdatedAt: string;
+  finishedAt?: string;
+}
+
+export type WorkflowRunStepStatus =
+  | "pending"
+  | "running"
+  | "waiting"
+  | "completed"
+  | "failed"
+  | "skipped";
+
+export interface WorkflowRunStep {
+  id: string;
+  runId: string;
+  nodeId: string;
+  nodeType: string;
+  status: WorkflowRunStepStatus;
+  input?: unknown;
+  output?: unknown;
+  error?: string;
+  retryCount?: number;
+  maxRetries?: number;
+  nextRetryAt?: string;
+  idempotencyKey?: string;
+  startedAt: string;
+  finishedAt?: string;
+}
+
+export interface WorkflowRunWithSteps extends WorkflowRun {
+  steps: WorkflowRunStep[];
+}
+
+export interface WorkflowVersion {
+  id: string;
+  workflowId: string;
+  version: number;
+  snapshot: {
+    name: string;
+    description?: string;
+    definition: WorkflowDefinition;
+    triggers: TriggerConfig[];
+    cooldown?: CooldownConfig;
+    input?: Record<string, string>;
+    enabled: boolean;
+  };
+  changedByAgentId?: string;
+  createdAt: string;
+}
+
+export interface WorkflowsResponse {
+  workflows: Workflow[];
+}
+
+export interface WorkflowRunsResponse {
+  runs: WorkflowRun[];
+}
+
+// Debug / DB Explorer
+export interface DbQueryRequest {
+  sql: string;
+  params?: unknown[];
+}
+
+export interface DbQueryResponse {
+  columns: string[];
+  rows: unknown[][];
+  elapsed: number;
+  total: number;
+}

package/new-ui/src/app/App.tsx

@@ -0,0 +1,13 @@
+import { RouterProvider } from "react-router-dom";
+import { Toaster } from "@/components/ui/sonner";
+import { Providers } from "./providers";
+import { router } from "./router";
+
+export default function App() {
+  return (
+    <Providers>
+      <RouterProvider router={router} />
+      <Toaster position="bottom-right" />
+    </Providers>
+  );
+}

package/new-ui/src/app/providers.tsx

@@ -0,0 +1,32 @@
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import type { ReactNode } from "react";
+import { TooltipProvider } from "@/components/ui/tooltip";
+import { ConfigContext, useConfigProvider } from "@/hooks/use-config";
+import { ThemeProvider } from "@/hooks/use-theme";
+
+const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      refetchInterval: 5000,
+      staleTime: 2000,
+      retry: 2,
+    },
+  },
+});
+
+function ConfigProvider({ children }: { children: ReactNode }) {
+  const value = useConfigProvider();
+  return <ConfigContext.Provider value={value}>{children}</ConfigContext.Provider>;
+}
+
+export function Providers({ children }: { children: ReactNode }) {
+  return (
+    <QueryClientProvider client={queryClient}>
+      <ThemeProvider>
+        <ConfigProvider>
+          <TooltipProvider>{children}</TooltipProvider>
+        </ConfigProvider>
+      </ThemeProvider>
+    </QueryClientProvider>
+  );
+}

package/new-ui/src/app/router.tsx

@@ -0,0 +1,52 @@
+import { lazy } from "react";
+import { createBrowserRouter } from "react-router-dom";
+import { RootLayout } from "@/components/layout/root-layout";
+
+const DashboardPage = lazy(() => import("@/pages/dashboard/page"));
+const AgentsPage = lazy(() => import("@/pages/agents/page"));
+const AgentDetailPage = lazy(() => import("@/pages/agents/[id]/page"));
+const TasksPage = lazy(() => import("@/pages/tasks/page"));
+const TaskDetailPage = lazy(() => import("@/pages/tasks/[id]/page"));
+const EpicsPage = lazy(() => import("@/pages/epics/page"));
+const EpicDetailPage = lazy(() => import("@/pages/epics/[id]/page"));
+const ChatPage = lazy(() => import("@/pages/chat/page"));
+const ServicesPage = lazy(() => import("@/pages/services/page"));
+const SchedulesPage = lazy(() => import("@/pages/schedules/page"));
+const ScheduleDetailPage = lazy(() => import("@/pages/schedules/[id]/page"));
+const UsagePage = lazy(() => import("@/pages/usage/page"));
+const ConfigPage = lazy(() => import("@/pages/config/page"));
+const ReposPage = lazy(() => import("@/pages/repos/page"));
+const WorkflowsPage = lazy(() => import("@/pages/workflows/page"));
+const WorkflowDetailPage = lazy(() => import("@/pages/workflows/[id]/page"));
+const WorkflowRunDetailPage = lazy(() => import("@/pages/workflow-runs/[id]/page"));
+const DebugPage = lazy(() => import("@/pages/debug/page"));
+const NotFoundPage = lazy(() => import("@/pages/not-found/page"));
+
+export const router = createBrowserRouter([
+  {
+    path: "/",
+    element: <RootLayout />,
+    children: [
+      { index: true, element: <DashboardPage /> },
+      { path: "agents", element: <AgentsPage /> },
+      { path: "agents/:id", element: <AgentDetailPage /> },
+      { path: "tasks", element: <TasksPage /> },
+      { path: "tasks/:id", element: <TaskDetailPage /> },
+      { path: "epics", element: <EpicsPage /> },
+      { path: "epics/:id", element: <EpicDetailPage /> },
+      { path: "chat", element: <ChatPage /> },
+      { path: "chat/:channelId", element: <ChatPage /> },
+      { path: "services", element: <ServicesPage /> },
+      { path: "schedules", element: <SchedulesPage /> },
+      { path: "schedules/:id", element: <ScheduleDetailPage /> },
+      { path: "workflows", element: <WorkflowsPage /> },
+      { path: "workflows/:id", element: <WorkflowDetailPage /> },
+      { path: "workflow-runs/:id", element: <WorkflowRunDetailPage /> },
+      { path: "usage", element: <UsagePage /> },
+      { path: "config", element: <ConfigPage /> },
+      { path: "repos", element: <ReposPage /> },
+      { path: "debug", element: <DebugPage /> },
+      { path: "*", element: <NotFoundPage /> },
+    ],
+  },
+]);

package/new-ui/src/components/layout/app-header.tsx

@@ -0,0 +1,47 @@
+import { Moon, Sun } from "lucide-react";
+import { useHealth } from "@/api/hooks/use-stats";
+import { Button } from "@/components/ui/button";
+import { Separator } from "@/components/ui/separator";
+import { SidebarTrigger } from "@/components/ui/sidebar";
+import { useConfig } from "@/hooks/use-config";
+import { useTheme } from "@/hooks/use-theme";
+import { cn } from "@/lib/utils";
+import { Breadcrumbs } from "./breadcrumbs";
+
+export function AppHeader() {
+  const { theme, toggleTheme } = useTheme();
+  const { data: health, isError } = useHealth();
+  const { activeConnection } = useConfig();
+
+  const isHealthy = health && !isError;
+
+  return (
+    <header className="flex h-14 items-center gap-2 border-b border-border px-4">
+      <SidebarTrigger className="md:hidden" />
+      <Separator orientation="vertical" className="mr-2 h-4 md:hidden" />
+
+      <Breadcrumbs />
+
+      <div className="flex-1" />
+
+      <div className="flex items-center gap-3">
+        {/* Health indicator */}
+        <div className="flex items-center gap-2 text-xs text-muted-foreground">
+          <div className={cn("size-2 rounded-full", isHealthy ? "bg-emerald-500" : "bg-red-500")} />
+          {activeConnection && (
+            <span className="hidden sm:inline font-medium">{activeConnection.name}</span>
+          )}
+          {activeConnection && <span className="hidden sm:inline">&mdash;</span>}
+          <span className="hidden sm:inline">{isHealthy ? "Connected" : "Disconnected"}</span>
+          {health?.version && <span>v{health.version}</span>}
+        </div>
+
+        {/* Theme toggle */}
+        <Button variant="ghost" size="icon" onClick={toggleTheme} className="size-8">
+          {theme === "dark" ? <Sun className="size-4" /> : <Moon className="size-4" />}
+          <span className="sr-only">Toggle theme</span>
+        </Button>
+      </div>
+    </header>
+  );
+}