@lucapimenta/copy-chief-dashboard 1.0.0

package/dashboard/src/stores/offer-store.ts

@@ -0,0 +1,119 @@
+import { create } from 'zustand';
+
+const API_BASE = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:4001';
+
+export interface OfferDeliverables {
+  vsl: number;
+  lp: number;
+  criativos: number;
+  emails: number;
+}
+
+export interface OfferStatus {
+  name: string;
+  nicho: string;
+  status?: 'active' | 'standby' | 'archived';
+  phase: string;
+  mecanismo_state: string;
+  production_count: number;
+  deliverables?: OfferDeliverables;
+  active_agent?: string | null;
+  last_activity?: number;
+  avg_quality: number;
+  rmbc?: { digerivel?: number; unico?: number; provavel?: number; conectado?: number };
+  blind_critic_score?: number;
+  est_score?: number;
+}
+
+// External listener pattern — notify without React re-render (AIOS pattern)
+type OfferChangeListener = (offer: string, phase: string) => void;
+const offerChangeListeners = new Set<OfferChangeListener>();
+
+export const onOfferChange = (fn: OfferChangeListener) => {
+  offerChangeListeners.add(fn);
+  return () => { offerChangeListeners.delete(fn); };
+};
+
+// Race condition guard for concurrent operations
+const operationsInProgress = new Set<string>();
+
+interface OfferState {
+  offers: OfferStatus[];
+  selectedOffer: string | null;
+  loading: boolean;
+  moveError: string | null;
+  setOffers: (offers: OfferStatus[]) => void;
+  selectOffer: (offer: string | null) => void;
+  setLoading: (loading: boolean) => void;
+  moveOffer: (offerId: string, newPhase: string) => Promise<{ ok: boolean; error?: string }>;
+  refreshOffer: (offer: string) => void;
+}
+
+export const useOfferStore = create<OfferState>((set, get) => ({
+  offers: [],
+  selectedOffer: null,
+  loading: false,
+  moveError: null,
+
+  setOffers: (offers) => {
+    const prev = get().offers;
+    set({ offers, loading: false });
+    // Notify external listeners on phase changes
+    for (const offer of offers) {
+      const key = `${offer.nicho}/${offer.name}`;
+      const prevOffer = prev.find((o) => `${o.nicho}/${o.name}` === key);
+      if (prevOffer && prevOffer.phase !== offer.phase) {
+        offerChangeListeners.forEach((fn) => fn(key, offer.phase));
+      }
+    }
+  },
+
+  selectOffer: (offer) => set({ selectedOffer: offer }),
+  setLoading: (loading) => set({ loading }),
+
+  moveOffer: async (offerId, newPhase) => {
+    // Race guard — prevent concurrent moves on same offer
+    if (operationsInProgress.has(offerId)) {
+      return { ok: false, error: 'Move already in progress' };
+    }
+    operationsInProgress.add(offerId);
+    set({ moveError: null });
+
+    // Optimistic update — move immediately in UI
+    const prevOffers = get().offers;
+    set({
+      offers: prevOffers.map((o) =>
+        `${o.nicho}/${o.name}` === offerId ? { ...o, phase: newPhase } : o
+      ),
+    });
+
+    try {
+      const res = await fetch(`${API_BASE}/offers/move`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ offer: offerId, newPhase }),
+      });
+      const result = await res.json();
+      if (!result.ok) {
+        // Snap-back on failure
+        set({ offers: prevOffers, moveError: result.error || 'Move failed' });
+        return { ok: false, error: result.error };
+      }
+      // Notify external listeners
+      offerChangeListeners.forEach((fn) => fn(offerId, newPhase));
+      return { ok: true };
+    } catch (err) {
+      // Snap-back on network error
+      const msg = err instanceof Error ? err.message : 'Network error';
+      set({ offers: prevOffers, moveError: msg });
+      return { ok: false, error: msg };
+    } finally {
+      operationsInProgress.delete(offerId);
+    }
+  },
+
+  refreshOffer: (_offer: string) => {
+    // SSE will auto-refresh — this is a manual trigger for cross-store sync
+    // No-op when SSE is active; used by clickup-store after sync execution
+  },
+}));

package/dashboard/src/stores/settings-store.ts

@@ -0,0 +1,29 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+interface SettingsState {
+  theme: 'dark' | 'light' | 'system';
+  autoRefresh: boolean;
+  refreshInterval: number;
+  showStandbyOffers: boolean;
+  setTheme: (theme: 'dark' | 'light' | 'system') => void;
+  setAutoRefresh: (enabled: boolean) => void;
+  setRefreshInterval: (ms: number) => void;
+  setShowStandbyOffers: (show: boolean) => void;
+}
+
+export const useSettingsStore = create<SettingsState>()(
+  persist(
+    (set) => ({
+      theme: 'dark',
+      autoRefresh: true,
+      refreshInterval: 30_000,
+      showStandbyOffers: false,
+      setTheme: (theme) => set({ theme }),
+      setAutoRefresh: (autoRefresh) => set({ autoRefresh }),
+      setRefreshInterval: (refreshInterval) => set({ refreshInterval }),
+      setShowStandbyOffers: (showStandbyOffers) => set({ showStandbyOffers }),
+    }),
+    { name: 'copy-chief-settings' }
+  )
+);

package/dashboard/src/stores/terminal-store.ts

@@ -0,0 +1,44 @@
+import { create } from 'zustand';
+
+export interface TerminalLine {
+  timestamp: number;
+  session_id: string;
+  tool_name: string;
+  text: string;
+  is_error: boolean;
+}
+
+interface TerminalState {
+  lines: Map<string, TerminalLine[]>;
+  activeSession: string | null;
+  viewMode: 'grid' | 'single';
+  addLine: (sessionId: string, line: TerminalLine) => void;
+  setActiveSession: (sessionId: string | null) => void;
+  setViewMode: (mode: 'grid' | 'single') => void;
+  clearSession: (sessionId: string) => void;
+}
+
+const MAX_LINES = 200;
+
+export const useTerminalStore = create<TerminalState>((set, get) => ({
+  lines: new Map(),
+  activeSession: null,
+  viewMode: 'grid',
+
+  addLine: (sessionId, line) => {
+    const lines = new Map(get().lines);
+    const existing = lines.get(sessionId) || [];
+    const updated = [...existing, line].slice(-MAX_LINES);
+    lines.set(sessionId, updated);
+    set({ lines });
+  },
+
+  setActiveSession: (activeSession) => set({ activeSession }),
+  setViewMode: (viewMode) => set({ viewMode }),
+
+  clearSession: (sessionId) => {
+    const lines = new Map(get().lines);
+    lines.delete(sessionId);
+    set({ lines });
+  },
+}));

package/dashboard/src/stores/ui-store.ts

@@ -0,0 +1,21 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+interface UIState {
+  sidebarCollapsed: boolean;
+  activeView: string;
+  toggleSidebar: () => void;
+  setActiveView: (view: string) => void;
+}
+
+export const useUIStore = create<UIState>()(
+  persist(
+    (set) => ({
+      sidebarCollapsed: false,
+      activeView: 'monitor',
+      toggleSidebar: () => set((s) => ({ sidebarCollapsed: !s.sidebarCollapsed })),
+      setActiveView: (view) => set({ activeView: view }),
+    }),
+    { name: 'copy-chief-ui' }
+  )
+);

package/dashboard/src/stores/warroom-store.ts

@@ -0,0 +1,39 @@
+import { create } from 'zustand';
+import type { AgentStatus } from '@/stores/agent-store';
+import type { DispatchEntry, WorkflowStep } from '@/stores/dispatch-store';
+import type { MonitorEvent } from '@/stores/monitor-store';
+
+interface WarRoomFilters {
+  agentFilter: string | null;
+  offerFilter: string | null;
+}
+
+interface WarRoomState {
+  agents: AgentStatus[];
+  dispatchEntries: DispatchEntry[];
+  workflowSteps: WorkflowStep[];
+  activityFeed: MonitorEvent[];
+  filters: WarRoomFilters;
+  setAgents: (agents: AgentStatus[]) => void;
+  setDispatchEntries: (entries: DispatchEntry[]) => void;
+  setWorkflowSteps: (steps: WorkflowStep[]) => void;
+  setActivityFeed: (events: MonitorEvent[]) => void;
+  setAgentFilter: (agent: string | null) => void;
+  setOfferFilter: (offer: string | null) => void;
+  clearFilters: () => void;
+}
+
+export const useWarRoomStore = create<WarRoomState>((set) => ({
+  agents: [],
+  dispatchEntries: [],
+  workflowSteps: [],
+  activityFeed: [],
+  filters: { agentFilter: null, offerFilter: null },
+  setAgents: (agents) => set({ agents }),
+  setDispatchEntries: (dispatchEntries) => set({ dispatchEntries }),
+  setWorkflowSteps: (workflowSteps) => set({ workflowSteps }),
+  setActivityFeed: (activityFeed) => set({ activityFeed }),
+  setAgentFilter: (agent) => set((s) => ({ filters: { ...s.filters, agentFilter: agent } })),
+  setOfferFilter: (offer) => set((s) => ({ filters: { ...s.filters, offerFilter: offer } })),
+  clearFilters: () => set({ filters: { agentFilter: null, offerFilter: null } }),
+}));

package/dashboard/tsconfig.json

@@ -0,0 +1,41 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    "next-env.d.ts",
+    "out/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}