@mesantosrai/pipeline-canvas 1.0.0

package/dist/store/pipelineStore.mjs

@@ -0,0 +1,633 @@
+import { create as b } from "zustand";
+import { persist as N, createJSONStorage as C } from "../node_modules/zustand/esm/middleware.mjs";
+import { topologicalSort as T } from "../utils/topologicalSort.mjs";
+let h = {};
+const B = (i) => {
+  h = i;
+}, A = () => h;
+let x = null;
+const m = "novoprotein-pipeline-draft", S = "Unnamed Pipeline", v = (i, d) => {
+  x && clearTimeout(x), x = setTimeout(async () => {
+    var t;
+    const { currentPipeline: e } = i();
+    if (e) {
+      d({ isSaving: !0 });
+      try {
+        const n = {
+          ...e,
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        localStorage.setItem(m, JSON.stringify(n));
+        const r = A(), a = (t = r.authState) == null ? void 0 : t.user, s = r.apiClient;
+        if (a && s)
+          try {
+            await s.post("/pipelines", {
+              ...n,
+              status: "draft"
+            }), console.log("[debouncedAutoSave] Draft pipeline saved to backend");
+          } catch (o) {
+            console.error("[debouncedAutoSave] Failed to save draft to backend:", o);
+          }
+        d({
+          lastSavedAt: /* @__PURE__ */ new Date(),
+          isSaving: !1
+        });
+      } catch (n) {
+        console.error("Auto-save failed:", n), d({ isSaving: !1 });
+      }
+    }
+  }, 1e3);
+}, $ = b()(
+  N(
+    (i, d) => ({
+      currentPipeline: null,
+      savedPipelines: [],
+      ghostBlueprint: null,
+      isExecuting: !1,
+      executionOrder: [],
+      currentExecution: null,
+      executionHistory: [],
+      viewMode: "editor",
+      selectedLogNodeId: null,
+      isPipelinesSidebarCollapsed: !1,
+      lastSavedAt: null,
+      isSaving: !1,
+      setCurrentPipeline: (e) => {
+        if (e) {
+          const { savedPipelines: t } = d(), n = t.findIndex((r) => r.id === e.id);
+          if (n >= 0) {
+            const r = [...t];
+            r[n] = e, i({ currentPipeline: e, savedPipelines: r });
+          } else
+            i({ currentPipeline: e });
+          v(d, i);
+        } else
+          i({ currentPipeline: null });
+      },
+      setGhostBlueprint: (e) => i({ ghostBlueprint: e }),
+      approveBlueprint: () => {
+        const { ghostBlueprint: e } = d();
+        if (!e) {
+          console.warn("[PipelineStore] approveBlueprint called but ghostBlueprint is null");
+          return;
+        }
+        const t = e.nodes.map((s, o) => ({
+          ...s,
+          status: "idle",
+          position: { x: 100 + o % 3 * 300, y: 100 + Math.floor(o / 3) * 200 }
+        })), n = {
+          id: `pipeline_${Date.now()}`,
+          name: S,
+          nodes: t,
+          edges: e.edges,
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date(),
+          status: "draft"
+        }, { savedPipelines: r } = d(), a = [...r, n];
+        console.log("[PipelineStore] approveBlueprint: Adding pipeline to savedPipelines", {
+          pipelineId: n.id,
+          pipelineName: n.name,
+          nodeCount: n.nodes.length,
+          currentSavedCount: r.length,
+          newSavedCount: a.length
+        }), i({
+          currentPipeline: n,
+          ghostBlueprint: null,
+          savedPipelines: a
+        }), v(d, i);
+      },
+      approveBlueprintWithSelection: (e, t) => {
+        const { ghostBlueprint: n } = d();
+        if (!n)
+          return console.warn("[PipelineStore] approveBlueprintWithSelection called but ghostBlueprint is null"), null;
+        const a = n.nodes.filter((P) => e.includes(P.id)).map((P, u) => ({
+          ...P,
+          config: { ...P.config, ...t[P.id] || {} },
+          status: "idle",
+          position: { x: 100 + u % 3 * 300, y: 100 + Math.floor(u / 3) * 200 }
+        })), s = new Set(e), o = n.edges.filter(
+          (P) => s.has(P.source) && s.has(P.target)
+        ), l = {
+          id: `pipeline_${Date.now()}`,
+          name: S,
+          nodes: a,
+          edges: o,
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date(),
+          status: "draft"
+        }, { savedPipelines: f } = d(), c = [...f, l];
+        return console.log("[PipelineStore] approveBlueprintWithSelection: Adding pipeline", {
+          pipelineId: l.id,
+          selectedNodeCount: a.length,
+          totalNodeCount: n.nodes.length
+        }), i({
+          currentPipeline: l,
+          ghostBlueprint: null,
+          savedPipelines: c
+        }), v(d, i), l;
+      },
+      rejectBlueprint: () => i({ ghostBlueprint: null }),
+      addNode: (e) => {
+        const { currentPipeline: t } = d();
+        if (t) {
+          const n = {
+            ...t,
+            nodes: [...t.nodes, e],
+            updatedAt: /* @__PURE__ */ new Date()
+          }, { savedPipelines: r } = d(), a = r.findIndex((s) => s.id === t.id);
+          if (a >= 0) {
+            const s = [...r];
+            s[a] = n, i({
+              currentPipeline: n,
+              savedPipelines: s
+            });
+          } else
+            i({ currentPipeline: n });
+          v(d, i);
+        } else {
+          const n = {
+            id: `pipeline_${Date.now()}`,
+            name: S,
+            nodes: [e],
+            edges: [],
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date(),
+            status: "draft"
+          }, { savedPipelines: r } = d();
+          i({
+            currentPipeline: n,
+            savedPipelines: [...r, n]
+          }), v(d, i);
+        }
+      },
+      updateNode: (e, t) => {
+        const { currentPipeline: n, savedPipelines: r } = d();
+        if (!n) return;
+        const a = {
+          ...n,
+          nodes: n.nodes.map((o) => {
+            if (o.id === e) {
+              const l = { ...o, ...t };
+              return t.config && o.config && (l.config = { ...o.config, ...t.config }), l;
+            }
+            return o;
+          }),
+          updatedAt: /* @__PURE__ */ new Date()
+        }, s = r.findIndex((o) => o.id === n.id);
+        if (s >= 0) {
+          const o = [...r];
+          o[s] = a, i({
+            currentPipeline: a,
+            savedPipelines: o
+          });
+        } else
+          i({ currentPipeline: a });
+        v(d, i);
+      },
+      deleteNode: (e) => {
+        const { currentPipeline: t, savedPipelines: n } = d();
+        if (!t) return;
+        const r = {
+          ...t,
+          nodes: t.nodes.filter((s) => s.id !== e),
+          edges: t.edges.filter(
+            (s) => s.source !== e && s.target !== e
+          ),
+          updatedAt: /* @__PURE__ */ new Date()
+        }, a = n.findIndex((s) => s.id === t.id);
+        if (a >= 0) {
+          const s = [...n];
+          s[a] = r, i({
+            currentPipeline: r,
+            savedPipelines: s
+          });
+        } else
+          i({ currentPipeline: r });
+        v(d, i);
+      },
+      addEdge: (e, t) => {
+        const { currentPipeline: n, savedPipelines: r } = d();
+        if (!n || n.edges.some(
+          (l) => l.source === e && l.target === t
+        )) return;
+        const s = {
+          ...n,
+          edges: [...n.edges, { source: e, target: t }],
+          updatedAt: /* @__PURE__ */ new Date()
+        }, o = r.findIndex((l) => l.id === n.id);
+        if (o >= 0) {
+          const l = [...r];
+          l[o] = s, i({
+            currentPipeline: s,
+            savedPipelines: l
+          });
+        } else
+          i({ currentPipeline: s });
+        v(d, i);
+      },
+      deleteEdge: (e, t) => {
+        const { currentPipeline: n, savedPipelines: r } = d();
+        if (!n) return;
+        const a = {
+          ...n,
+          edges: n.edges.filter(
+            (o) => !(o.source === e && o.target === t)
+          ),
+          updatedAt: /* @__PURE__ */ new Date()
+        }, s = r.findIndex((o) => o.id === n.id);
+        if (s >= 0) {
+          const o = [...r];
+          o[s] = a, i({
+            currentPipeline: a,
+            savedPipelines: o
+          });
+        } else
+          i({ currentPipeline: a });
+        v(d, i);
+      },
+      savePipeline: async (e, t, n, r) => {
+        var g;
+        const { currentPipeline: a, savedPipelines: s } = d();
+        if (!a) return;
+        const o = {
+          ...a,
+          name: e,
+          updatedAt: /* @__PURE__ */ new Date()
+        }, l = r || A(), f = (g = l.authState) == null ? void 0 : g.user, c = l.apiClient, P = l.sessionId;
+        if (f && c)
+          try {
+            const p = { ...o };
+            t && (p.message_id = t), n ? p.conversation_id = n : !n && t && P && (p.conversation_id = P), await c.post("/pipelines", p), console.log("Pipeline saved to backend", t ? `(linked to message ${t})` : "");
+          } catch (p) {
+            console.error("Failed to save pipeline to backend:", p);
+          }
+        const u = s.findIndex((p) => p.id === o.id);
+        if (u >= 0) {
+          const p = [...s];
+          p[u] = o, i({
+            savedPipelines: p,
+            lastSavedAt: /* @__PURE__ */ new Date()
+          });
+        } else
+          i({
+            savedPipelines: [...s, o],
+            lastSavedAt: /* @__PURE__ */ new Date()
+          });
+        try {
+          localStorage.setItem(m, JSON.stringify(o));
+        } catch (p) {
+          console.error("Failed to save draft:", p);
+        }
+      },
+      loadPipeline: async (e, t) => {
+        var l;
+        const { savedPipelines: n } = d(), r = t || A(), a = (l = r.authState) == null ? void 0 : l.user, s = r.apiClient;
+        if (a && s)
+          try {
+            const c = (await s.get(`/pipelines/${e}`)).data.pipeline;
+            c.createdAt && (c.createdAt = new Date(c.createdAt)), c.updatedAt && (c.updatedAt = new Date(c.updatedAt));
+            const P = n.findIndex((u) => u.id === e);
+            if (P >= 0) {
+              const u = [...n];
+              u[P] = c, i({ savedPipelines: u });
+            } else
+              i({ savedPipelines: [...n, c] });
+            i({
+              currentPipeline: { ...c },
+              lastSavedAt: c.updatedAt || /* @__PURE__ */ new Date()
+            });
+            return;
+          } catch (f) {
+            console.warn("Failed to load pipeline from backend, using local:", f);
+          }
+        const o = n.find((f) => f.id === e);
+        if (o) {
+          const f = o.updatedAt instanceof Date ? o.updatedAt : new Date(o.updatedAt);
+          i({
+            currentPipeline: { ...o },
+            lastSavedAt: isNaN(f.getTime()) ? /* @__PURE__ */ new Date() : f
+          });
+        }
+      },
+      deletePipeline: async (e, t) => {
+        var l;
+        const n = t || A(), r = (l = n.authState) == null ? void 0 : l.user, a = n.apiClient;
+        if (r && a && a.delete)
+          try {
+            await a.delete(`/pipelines/${e}`), console.log("Pipeline deleted from backend");
+          } catch (f) {
+            console.warn("Failed to delete pipeline from backend:", f);
+          }
+        else if (r && a)
+          try {
+            await a.post(`/pipelines/${e}`, {}, { headers: { "X-HTTP-Method-Override": "DELETE" } }), console.log("Pipeline deleted from backend");
+          } catch (f) {
+            console.warn("Failed to delete pipeline from backend:", f);
+          }
+        const { savedPipelines: s, currentPipeline: o } = d();
+        i({
+          savedPipelines: s.filter((f) => f.id !== e),
+          currentPipeline: (o == null ? void 0 : o.id) === e ? null : o
+        });
+      },
+      syncPipelines: async (e) => {
+        var a, s;
+        const t = e || A(), n = (a = t.authState) == null ? void 0 : a.user, r = t.apiClient;
+        if (!n || !r) {
+          console.log("[syncPipelines] User not authenticated or API client not available, skipping pipeline sync");
+          return;
+        }
+        try {
+          console.log("[syncPipelines] Fetching pipelines from backend for user:", n.id);
+          const o = await r.get("/pipelines");
+          console.log("[syncPipelines] API response:", o.data);
+          const l = o.data.pipelines || [];
+          console.log(`[syncPipelines] Found ${l.length} pipelines in backend`);
+          const c = (await Promise.all(
+            l.map(async (u) => {
+              try {
+                console.log(`[syncPipelines] Loading full pipeline data for: ${u.id}`);
+                const p = (await r.get(`/pipelines/${u.id}`)).data.pipeline;
+                return p.createdAt && (p.createdAt = new Date(p.createdAt)), p.updatedAt && (p.updatedAt = new Date(p.updatedAt)), console.log(`[syncPipelines] Successfully loaded pipeline: ${p.name || p.id}`), p;
+              } catch (g) {
+                return console.error(`[syncPipelines] Failed to load full pipeline ${u.id}:`, g), g.response && console.error(`[syncPipelines] Response status: ${g.response.status}`, g.response.data), null;
+              }
+            })
+          )).filter((u) => u !== null);
+          i({ savedPipelines: c }), console.log(`[syncPipelines] Synced ${c.length} pipelines from backend`);
+          const P = c.filter((u) => u.status === "draft");
+          if (P.length > 0) {
+            const u = P.reduce((g, p) => {
+              var D, y;
+              const w = ((D = g.updatedAt) == null ? void 0 : D.getTime()) || 0;
+              return (((y = p.updatedAt) == null ? void 0 : y.getTime()) || 0) > w ? p : g;
+            });
+            try {
+              const g = localStorage.getItem(m);
+              if (g) {
+                const p = JSON.parse(g), w = p.updatedAt ? new Date(p.updatedAt).getTime() : 0;
+                (((s = u.updatedAt) == null ? void 0 : s.getTime()) || 0) > w && (console.log("[syncPipelines] Loading draft from backend (newer than local)"), i({ currentPipeline: u }));
+              } else
+                console.log("[syncPipelines] Loading draft from backend (no local draft)"), i({ currentPipeline: u });
+            } catch (g) {
+              console.error("[syncPipelines] Failed to compare drafts:", g), i({ currentPipeline: u });
+            }
+          }
+        } catch (o) {
+          console.error("[syncPipelines] Failed to sync pipelines from backend:", o), o.response && (console.error("[syncPipelines] Response status:", o.response.status), console.error("[syncPipelines] Response data:", o.response.data));
+        }
+      },
+      startExecution: () => {
+        var a;
+        const { currentPipeline: e } = d();
+        if (!e) return;
+        const t = e.nodes.filter((s) => s.type === "input_node");
+        for (const s of t)
+          if (!((a = s.config) != null && a.filename)) {
+            const o = s.id;
+            i({
+              currentPipeline: {
+                ...e,
+                nodes: e.nodes.map(
+                  (l) => l.id === o ? { ...l, status: "error", error: "No filename specified for input node" } : l
+                )
+              }
+            });
+            return;
+          }
+        const n = T(e.nodes, e.edges), r = {
+          id: `exec_${Date.now()}`,
+          startedAt: /* @__PURE__ */ new Date(),
+          status: "running",
+          logs: []
+        };
+        i({
+          isExecuting: !0,
+          executionOrder: n,
+          currentExecution: r,
+          // Don't auto-switch to executions view - stay in editor so users can see output
+          // viewMode: 'executions', // Removed - keep current view mode
+          currentPipeline: {
+            ...e,
+            status: "running",
+            nodes: e.nodes.map((s) => ({
+              ...s,
+              status: s.status === "success" || s.status === "completed" ? s.status : "pending"
+            }))
+          }
+        }), window.dispatchEvent(new CustomEvent("pipeline-started", {
+          detail: {
+            pipelineId: e.id,
+            status: "running",
+            nodes: e.nodes.map((s) => ({
+              id: s.id,
+              label: s.label,
+              status: s.status === "success" || s.status === "completed" ? s.status : "pending"
+            }))
+          }
+        }));
+      },
+      executeSingleNode: (e) => {
+        var o;
+        const { currentPipeline: t, addExecutionLog: n } = d();
+        if (!t) return;
+        const r = t.nodes.find((l) => l.id === e);
+        if (!r) return;
+        if (r.type === "input_node" && !((o = r.config) != null && o.filename)) {
+          i({
+            currentPipeline: {
+              ...t,
+              nodes: t.nodes.map(
+                (l) => l.id === e ? { ...l, status: "error", error: "No filename specified for input node" } : l
+              )
+            }
+          });
+          return;
+        }
+        const a = [e], s = {
+          id: `exec_${Date.now()}`,
+          startedAt: /* @__PURE__ */ new Date(),
+          status: "running",
+          logs: []
+        };
+        n({
+          nodeId: e,
+          nodeLabel: r.label,
+          nodeType: r.type,
+          status: "running"
+        }), i({
+          isExecuting: !0,
+          executionOrder: a,
+          currentExecution: s,
+          currentPipeline: {
+            ...t,
+            status: "running",
+            nodes: t.nodes.map(
+              (l) => l.id === e ? { ...l, status: "pending" } : l
+            )
+          }
+        });
+      },
+      stopExecution: () => {
+        const { currentPipeline: e, currentExecution: t, executionHistory: n } = d();
+        if (t) {
+          const r = {
+            ...t,
+            completedAt: /* @__PURE__ */ new Date(),
+            status: "stopped"
+          };
+          i({
+            executionHistory: [r, ...n].slice(0, 50),
+            // Keep last 50
+            // Keep currentExecution so users can view results after execution completes
+            // It will be cleared when a new execution starts
+            currentExecution: {
+              ...r,
+              status: "completed"
+            }
+          });
+        }
+        i({ isExecuting: !1 }), e && i({
+          currentPipeline: {
+            ...e,
+            status: "draft"
+          }
+        });
+      },
+      updateNodeStatus: (e, t, n) => {
+        const { currentPipeline: r, currentExecution: a } = d();
+        if (!r) return;
+        const s = r.nodes.find((l) => l.id === e), o = { status: t };
+        if (n && (o.error = n), (t === "success" || t === "completed") && !(s != null && s.result_metadata) && (o.result_metadata = {}), a && s) {
+          const l = a.logs.findIndex((c) => c.nodeId === e), f = /* @__PURE__ */ new Date();
+          if (l >= 0) {
+            const c = a.logs[l], P = {
+              ...c,
+              // Preserve all existing fields (request, response, input, output, etc.)
+              status: t,
+              error: n || c.error,
+              // Update error if provided, otherwise keep existing
+              completedAt: t === "success" || t === "error" ? c.completedAt || f : void 0,
+              duration: c.startedAt && (t === "success" || t === "error") ? c.duration || f.getTime() - new Date(c.startedAt).getTime() : c.duration
+              // Preserve existing duration if not completed
+            }, u = [...a.logs];
+            u[l] = P, i({
+              currentExecution: {
+                ...a,
+                logs: u
+              }
+            });
+          } else if (t === "running" || t === "pending") {
+            const c = {
+              nodeId: e,
+              nodeLabel: s.label,
+              nodeType: s.type,
+              status: t,
+              startedAt: f
+            };
+            i({
+              currentExecution: {
+                ...a,
+                logs: [...a.logs, c]
+              }
+            });
+          }
+        }
+        i({
+          currentPipeline: {
+            ...r,
+            nodes: r.nodes.map(
+              (l) => l.id === e ? { ...l, ...o } : l
+            ),
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        }), v(d, i);
+      },
+      clearPipeline: () => {
+        i({
+          currentPipeline: null,
+          ghostBlueprint: null,
+          isExecuting: !1,
+          executionOrder: [],
+          currentExecution: null,
+          lastSavedAt: null
+        });
+        try {
+          localStorage.removeItem(m);
+        } catch (e) {
+          console.error("Failed to clear draft:", e);
+        }
+      },
+      setViewMode: (e) => i({ viewMode: e }),
+      setSelectedLogNodeId: (e) => i({ selectedLogNodeId: e }),
+      setPipelinesSidebarCollapsed: (e) => i({ isPipelinesSidebarCollapsed: e }),
+      togglePipelinesSidebar: () => i((e) => ({ isPipelinesSidebarCollapsed: !e.isPipelinesSidebarCollapsed })),
+      addExecutionLog: (e) => {
+        const { currentExecution: t } = d();
+        if (!t) return;
+        const n = {
+          ...e,
+          startedAt: /* @__PURE__ */ new Date()
+        };
+        i({
+          currentExecution: {
+            ...t,
+            logs: [...t.logs, n]
+          }
+        });
+      },
+      updateExecutionLog: (e, t) => {
+        const { currentExecution: n } = d();
+        if (!n) return;
+        const r = n.logs.findIndex((s) => s.nodeId === e);
+        if (r === -1) return;
+        const a = [...n.logs];
+        a[r] = { ...a[r], ...t }, i({
+          currentExecution: {
+            ...n,
+            logs: a
+          }
+        });
+      }
+    }),
+    {
+      name: "novoprotein-pipeline-storage",
+      version: 1,
+      storage: C(() => localStorage),
+      partialize: (i) => ({
+        // Persist all pipelines including unnamed ones
+        savedPipelines: i.savedPipelines
+        // Don't persist currentPipeline or execution state - it's saved as draft separately
+      }),
+      // Load draft on initialization
+      onRehydrateStorage: () => (i) => {
+        if (i) {
+          try {
+            i.savedPipelines = i.savedPipelines.map((e) => (e.createdAt && typeof e.createdAt == "string" && (e.createdAt = new Date(e.createdAt)), e.updatedAt && typeof e.updatedAt == "string" && (e.updatedAt = new Date(e.updatedAt)), e));
+            const d = localStorage.getItem(m);
+            if (d) {
+              const e = JSON.parse(d);
+              if (i.setCurrentPipeline(e), e.updatedAt) {
+                const t = e.updatedAt instanceof Date ? e.updatedAt : new Date(e.updatedAt);
+                i.lastSavedAt = isNaN(t.getTime()) ? /* @__PURE__ */ new Date() : t;
+              } else
+                i.lastSavedAt = /* @__PURE__ */ new Date();
+            }
+          } catch (d) {
+            console.error("Failed to load draft:", d);
+          }
+          setTimeout(() => {
+            var n;
+            const d = A(), e = (n = d.authState) == null ? void 0 : n.user, t = d.apiClient;
+            e && t && i.syncPipelines && i.syncPipelines({ apiClient: t, authState: d.authState }).catch(console.error);
+          }, 1e3);
+        }
+      }
+    }
+  )
+);
+export {
+  B as setPipelineDependencies,
+  $ as usePipelineStore
+};
+//# sourceMappingURL=pipelineStore.mjs.map