conductor-oss 0.2.15 → 0.2.16

package/web/.next/standalone/packages/web/src/hooks/useSessionFeed.ts

@@ -0,0 +1,265 @@
+"use client";
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import type { NormalizedChatEntry } from "@/lib/chatFeed";
+import { subscribeToSnapshotEvents } from "@/lib/liveEvents";
+import { TERMINAL_STATUSES, type SSESnapshotEvent } from "@/lib/types";
+const ACTIVE_POLL_INTERVAL_MS = 1000;
+const HIDDEN_POLL_INTERVAL_MS = 1000;
+const TERMINAL_POLL_INTERVAL_MS = 10_000;
+
+interface SessionFeedResponse {
+  entries?: NormalizedChatEntry[];
+  sessionStatus?: string | null;
+  parserState?: {
+    kind?: string | null;
+    message?: string | null;
+    command?: string | null;
+  } | null;
+}
+
+export interface SessionParserState {
+  kind: string;
+  message: string;
+  command: string | null;
+}
+
+interface UseSessionFeedResult {
+  entries: NormalizedChatEntry[];
+  loading: boolean;
+  error: string | null;
+  sessionStatus: string | null;
+  parserState: SessionParserState | null;
+  refresh: () => Promise<void>;
+}
+
+function entriesEqual(left: NormalizedChatEntry[], right: NormalizedChatEntry[]): boolean {
+  if (left === right) return true;
+  if (left.length !== right.length) return false;
+
+  for (let index = 0; index < left.length; index += 1) {
+    const a = left[index];
+    const b = right[index];
+    if (!a || !b) return false;
+    if (
+      a.id !== b.id
+      || a.kind !== b.kind
+      || a.label !== b.label
+      || a.text !== b.text
+      || a.createdAt !== b.createdAt
+      || a.streaming !== b.streaming
+      || a.source !== b.source
+      || a.attachments.length !== b.attachments.length
+    ) {
+      return false;
+    }
+    const aToolTitle = typeof a.metadata?.toolTitle === "string" ? a.metadata.toolTitle : null;
+    const bToolTitle = typeof b.metadata?.toolTitle === "string" ? b.metadata.toolTitle : null;
+    const aToolStatus = typeof a.metadata?.toolStatus === "string" ? a.metadata.toolStatus : null;
+    const bToolStatus = typeof b.metadata?.toolStatus === "string" ? b.metadata.toolStatus : null;
+    const aToolKind = typeof a.metadata?.toolKind === "string" ? a.metadata.toolKind : null;
+    const bToolKind = typeof b.metadata?.toolKind === "string" ? b.metadata.toolKind : null;
+    const aToolContent = Array.isArray(a.metadata?.toolContent) ? a.metadata.toolContent : [];
+    const bToolContent = Array.isArray(b.metadata?.toolContent) ? b.metadata.toolContent : [];
+    if (
+      aToolTitle !== bToolTitle
+      || aToolStatus !== bToolStatus
+      || aToolKind !== bToolKind
+      || aToolContent.length !== bToolContent.length
+    ) {
+      return false;
+    }
+    for (let toolIndex = 0; toolIndex < aToolContent.length; toolIndex += 1) {
+      if (aToolContent[toolIndex] !== bToolContent[toolIndex]) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+function normalizeParserState(value: SessionFeedResponse["parserState"]): SessionParserState | null {
+  if (!value || typeof value !== "object") return null;
+  const kind = typeof value.kind === "string" ? value.kind.trim() : "";
+  const message = typeof value.message === "string" ? value.message.trim() : "";
+  const command = typeof value.command === "string" && value.command.trim().length > 0
+    ? value.command.trim()
+    : null;
+  if (!kind || !message) return null;
+  return { kind, message, command };
+}
+
+async function fetchFeed(sessionId: string): Promise<SessionFeedResponse> {
+  const response = await fetch(`/api/sessions/${encodeURIComponent(sessionId)}/feed`, {
+    cache: "no-store",
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to load chat feed: ${response.status}`);
+  }
+
+  return response.json() as Promise<SessionFeedResponse>;
+}
+
+export function useSessionFeed(sessionId: string | null | undefined): UseSessionFeedResult {
+  const [entries, setEntries] = useState<NormalizedChatEntry[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [sessionStatus, setSessionStatus] = useState<string | null>(null);
+  const [parserState, setParserState] = useState<SessionParserState | null>(null);
+  const terminalRef = useRef(false);
+  const mountedRef = useRef(true);
+  const inFlightRef = useRef(false);
+  const pendingRef = useRef(false);
+  const snapshotSignatureRef = useRef<string | null>(null);
+
+  const applyPayload = useCallback((payload: SessionFeedResponse) => {
+    const nextEntries = Array.isArray(payload.entries) ? payload.entries : [];
+    setEntries((current) => {
+      return entriesEqual(current, nextEntries) ? current : nextEntries;
+    });
+    const status = typeof payload.sessionStatus === "string" ? payload.sessionStatus : null;
+    setSessionStatus(status);
+    if (status && TERMINAL_STATUSES.has(status)) {
+      terminalRef.current = true;
+    }
+    setParserState((current) => {
+      const next = normalizeParserState(payload.parserState);
+      if (current === null && next === null) return current;
+      if (current?.kind === next?.kind && current?.message === next?.message && current?.command === next?.command) {
+        return current;
+      }
+      return next;
+    });
+    setError(null);
+    setLoading(false);
+  }, []);
+
+  const refresh = useCallback(async () => {
+    if (!sessionId) {
+      setEntries([]);
+      setLoading(false);
+      setError(null);
+      setSessionStatus(null);
+      setParserState(null);
+      return;
+    }
+
+    if (inFlightRef.current) {
+      pendingRef.current = true;
+      return;
+    }
+
+    inFlightRef.current = true;
+
+    do {
+      try {
+        const payload = await fetchFeed(sessionId);
+        if (!mountedRef.current) break;
+        applyPayload(payload);
+      } catch (err) {
+        if (!mountedRef.current) break;
+        const message = err instanceof Error ? err.message : "Failed to load chat feed";
+        if (message.includes("404")) {
+          setEntries([]);
+          setSessionStatus(null);
+          setParserState(null);
+        }
+        setError(message);
+        setLoading(false);
+      }
+
+      if (!pendingRef.current) break;
+      pendingRef.current = false;
+    } while (mountedRef.current);
+
+    inFlightRef.current = false;
+  }, [sessionId]);
+
+  useEffect(() => {
+    mountedRef.current = true;
+    terminalRef.current = false;
+    snapshotSignatureRef.current = null;
+    pendingRef.current = false;
+    setEntries([]);
+    setSessionStatus(null);
+    setParserState(null);
+    setError(null);
+    setLoading(true);
+    void refresh();
+
+    if (!sessionId) {
+      return () => {
+        mountedRef.current = false;
+      };
+    }
+    const handleWindowFocus = () => {
+      if (!terminalRef.current) {
+        snapshotSignatureRef.current = null;
+        void refresh();
+      }
+    };
+    const handleVisibilityChange = () => {
+      if (document.visibilityState === "visible" && !terminalRef.current) {
+        snapshotSignatureRef.current = null;
+        void refresh();
+      }
+    };
+    window.addEventListener("focus", handleWindowFocus);
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+
+    let intervalId: number | null = null;
+
+    const startPolling = () => {
+      if (intervalId !== null) return;
+      const interval = terminalRef.current
+        ? TERMINAL_POLL_INTERVAL_MS
+        : document.visibilityState === "visible"
+          ? ACTIVE_POLL_INTERVAL_MS
+          : HIDDEN_POLL_INTERVAL_MS;
+      intervalId = window.setInterval(() => {
+        void refresh();
+      }, interval);
+    };
+
+    const stopPolling = () => {
+      if (intervalId === null) return;
+      window.clearInterval(intervalId);
+      intervalId = null;
+    };
+
+    startPolling();
+    const unsubscribe = subscribeToSnapshotEvents((payload: SSESnapshotEvent) => {
+      if (!mountedRef.current) return;
+      const matchingSession = payload.sessions.find((value) => value.id === sessionId);
+      const signature = matchingSession
+        ? [
+          matchingSession.id,
+          matchingSession.status,
+          matchingSession.activity ?? "",
+          matchingSession.lastActivityAt,
+          matchingSession.summary ?? "",
+        ].join(":")
+        : "missing";
+      if (snapshotSignatureRef.current === signature) {
+        return;
+      }
+      snapshotSignatureRef.current = signature;
+      void refresh();
+    });
+
+    return () => {
+      mountedRef.current = false;
+      stopPolling();
+      unsubscribe();
+      window.removeEventListener("focus", handleWindowFocus);
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+    };
+  }, [refresh, sessionId]);
+
+  return useMemo(
+    () => ({ entries, loading, error, sessionStatus, parserState, refresh }),
+    [entries, error, loading, parserState, refresh, sessionStatus],
+  );
+}

package/web/.next/standalone/packages/web/src/hooks/useSessionOutputStream.ts

@@ -0,0 +1,155 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+
+type OutputStreamEvent =
+  | { type: "output"; output: string }
+  | { type: "delta"; line: string }
+  | { type: "error"; error: string };
+
+interface UseSessionOutputStreamOptions {
+  lines?: number;
+  pollIntervalMs?: number;
+}
+
+interface UseSessionOutputStreamReturn {
+  output: string;
+  connected: boolean;
+  error: string | null;
+  refresh: () => Promise<void>;
+}
+
+export function useSessionOutputStream(
+  sessionId: string,
+  options: UseSessionOutputStreamOptions = {},
+): UseSessionOutputStreamReturn {
+  const { lines = 500, pollIntervalMs = 1000 } = options;
+  const [output, setOutput] = useState("");
+  const [connected, setConnected] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const mountedRef = useRef(true);
+
+  const fetchOutput = useCallback(async () => {
+    try {
+      const res = await fetch(`/api/sessions/${encodeURIComponent(sessionId)}/output?lines=${lines}`);
+      if (!res.ok) {
+        if (res.status === 404) {
+          if (!mountedRef.current) return;
+          setOutput("");
+          setConnected(false);
+          setError(null);
+          return;
+        }
+        const body = (await res.json().catch(() => null)) as { error?: string } | null;
+        throw new Error(body?.error ?? `Failed to fetch output: ${res.status}`);
+      }
+      const data = (await res.json()) as { output?: string };
+      if (!mountedRef.current) return;
+      setOutput(typeof data.output === "string" ? data.output : "");
+      setConnected(true);
+      setError(null);
+    } catch (err) {
+      if (!mountedRef.current) return;
+      setConnected(false);
+      setError(err instanceof Error ? err.message : "Failed to fetch output");
+    }
+  }, [lines, sessionId]);
+
+  useEffect(() => {
+    mountedRef.current = true;
+    setOutput("");
+    setConnected(false);
+    setError(null);
+    void fetchOutput();
+
+    let eventSource: EventSource | null = null;
+    let pollingId: number | null = null;
+
+    const startPolling = () => {
+      if (pollingId !== null) return;
+      pollingId = window.setInterval(() => {
+        if (mountedRef.current) void fetchOutput();
+      }, pollIntervalMs);
+    };
+
+    const stopPolling = () => {
+      if (pollingId === null) return;
+      window.clearInterval(pollingId);
+      pollingId = null;
+    };
+
+    if (typeof EventSource !== "undefined") {
+      eventSource = new EventSource(
+        `/api/sessions/${encodeURIComponent(sessionId)}/output/stream?lines=${lines}`,
+      );
+
+      eventSource.onopen = () => {
+        if (!mountedRef.current) return;
+        stopPolling();
+        setConnected(true);
+        setError(null);
+      };
+
+      eventSource.onmessage = (event) => {
+        if (!mountedRef.current) return;
+        try {
+          const payload = JSON.parse(event.data as string) as OutputStreamEvent;
+          if (payload.type === "output") {
+            setOutput(payload.output ?? "");
+            setConnected(true);
+            setError(null);
+            return;
+          }
+
+          if (payload.type === "delta") {
+            setOutput((prev) => (prev ? `${prev}\n${payload.line}` : payload.line));
+            setConnected(true);
+            setError(null);
+            return;
+          }
+
+          if (payload.type === "error") {
+            const normalized = (payload.error || "").toLowerCase();
+            setConnected(false);
+            if (
+              normalized.includes("not found") ||
+              normalized.includes("workspace") ||
+              normalized.includes("no output")
+            ) {
+              setError(null);
+              setOutput("");
+            } else {
+              setError(payload.error || "Output stream error");
+            }
+            startPolling();
+            void fetchOutput();
+          }
+        } catch {
+          // Ignore malformed stream messages.
+        }
+      };
+
+      eventSource.onerror = () => {
+        if (!mountedRef.current) return;
+        setConnected(false);
+        startPolling();
+        void fetchOutput();
+      };
+    } else {
+      startPolling();
+    }
+
+    return () => {
+      mountedRef.current = false;
+      stopPolling();
+      if (eventSource) eventSource.close();
+    };
+  }, [fetchOutput, lines, pollIntervalMs, sessionId]);
+
+  return {
+    output,
+    connected,
+    error,
+    refresh: fetchOutput,
+  };
+}

package/web/.next/standalone/packages/web/src/hooks/useSessions.ts

@@ -0,0 +1,123 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import { subscribeToSnapshotEvents } from "@/lib/liveEvents";
+import type { SSESnapshotEvent } from "@/lib/types";
+
+interface Session {
+  id: string;
+  status: string;
+  createdAt: string;
+  [key: string]: unknown;
+}
+
+interface UseSessionsReturn {
+  sessions: Session[];
+  loading: boolean;
+  error: string | null;
+  refresh: () => Promise<void>;
+}
+
+function sessionsEqual(left: Session[], right: Session[]): boolean {
+  if (left === right) return true;
+  if (left.length !== right.length) return false;
+
+  for (let index = 0; index < left.length; index += 1) {
+    const a = left[index];
+    const b = right[index];
+    if (!a || !b) return false;
+
+    if (
+      a.id !== b.id ||
+      a.status !== b.status ||
+      a["activity"] !== b["activity"] ||
+      a["projectId"] !== b["projectId"] ||
+      a["issueId"] !== b["issueId"] ||
+      a["branch"] !== b["branch"] ||
+      a["lastActivityAt"] !== b["lastActivityAt"] ||
+      a["summary"] !== b["summary"]
+    ) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function filterByProject(sessions: Session[], projectId?: string | null): Session[] {
+  const normalized = projectId?.trim();
+  if (!normalized) return sessions;
+  return sessions.filter((session) => session["projectId"] === normalized);
+}
+
+export function useSessions(projectId?: string | null): UseSessionsReturn {
+  const [sessions, setSessions] = useState<Session[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const mountedRef = useRef(true);
+
+  const applySessions = useCallback((nextSessions: Session[]) => {
+    setSessions((prev) => (sessionsEqual(prev, nextSessions) ? prev : nextSessions));
+  }, []);
+
+  const fetchSessions = useCallback(async () => {
+    try {
+      const query = typeof projectId === "string" && projectId.trim().length > 0
+        ? `?project=${encodeURIComponent(projectId.trim())}`
+        : "";
+      const res = await fetch(`/api/sessions${query}`);
+      if (!res.ok) throw new Error(`Failed to fetch sessions: ${res.status}`);
+      const json = await res.json();
+      const data = Array.isArray(json)
+        ? json
+        : Array.isArray((json as { sessions?: unknown }).sessions)
+          ? (json as { sessions: Session[] }).sessions
+          : [];
+      if (!mountedRef.current) return;
+      applySessions(data);
+      setError(null);
+    } catch (err) {
+      if (mountedRef.current) setError(err instanceof Error ? err.message : "Unknown error");
+    } finally {
+      if (mountedRef.current) setLoading(false);
+    }
+  }, [applySessions, projectId]);
+
+  useEffect(() => {
+    mountedRef.current = true;
+    setLoading(true);
+    void fetchSessions();
+
+    let pollingId: number | null = null;
+
+    const startPolling = () => {
+      if (pollingId !== null) return;
+      pollingId = window.setInterval(() => {
+        if (mountedRef.current) void fetchSessions();
+      }, 3000);
+    };
+
+    const stopPolling = () => {
+      if (pollingId === null) return;
+      window.clearInterval(pollingId);
+      pollingId = null;
+    };
+
+    startPolling();
+    const unsubscribe = subscribeToSnapshotEvents((data: SSESnapshotEvent) => {
+      if (!mountedRef.current) return;
+      const filtered = filterByProject(data.sessions as unknown as Session[], projectId);
+      applySessions(filtered);
+      setError(null);
+      setLoading(false);
+    });
+
+    return () => {
+      mountedRef.current = false;
+      unsubscribe();
+      stopPolling();
+    };
+  }, [applySessions, fetchSessions, projectId]);
+
+  return { sessions, loading, error, refresh: fetchSessions };
+}

package/web/.next/standalone/packages/web/src/lib/accessControl.test.ts

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { isLoopbackHost, resolveRoleForEmail, roleMeetsRequirement } from "./accessControl";
+
+test("resolveRoleForEmail prefers the highest matching bound role", () => {
+  const resolution = resolveRoleForEmail("lead@example.com", {
+    roles: {
+      viewers: ["lead@example.com"],
+      admins: ["lead@example.com"],
+    },
+  });
+
+  assert.equal(resolution.role, "admin");
+  assert.equal(resolution.matchedBinding, true);
+});
+
+test("resolveRoleForEmail falls back to the configured default role", () => {
+  const resolution = resolveRoleForEmail("member@example.com", {
+    defaultRole: "viewer",
+  });
+
+  assert.equal(resolution.role, "viewer");
+  assert.equal(resolution.matchedBinding, false);
+});
+
+test("resolveRoleForEmail denies unmatched users when explicit bindings exist", () => {
+  const resolution = resolveRoleForEmail("outsider@example.com", {
+    roles: {
+      operators: ["operator@example.com"],
+    },
+  });
+
+  assert.equal(resolution.role, null);
+});
+
+test("roleMeetsRequirement enforces the viewer/operator/admin hierarchy", () => {
+  assert.equal(roleMeetsRequirement("admin", "operator"), true);
+  assert.equal(roleMeetsRequirement("operator", "viewer"), true);
+  assert.equal(roleMeetsRequirement("viewer", "operator"), false);
+});
+
+test("isLoopbackHost recognizes local dashboard hosts", () => {
+  assert.equal(isLoopbackHost("localhost"), true);
+  assert.equal(isLoopbackHost("127.0.0.1"), true);
+  assert.equal(isLoopbackHost("app.example.com"), false);
+});

package/web/.next/standalone/packages/web/src/lib/accessControl.ts

@@ -0,0 +1,115 @@
+import type {
+  DashboardAccessConfig,
+  DashboardRole,
+  DashboardRoleBindings,
+} from "@conductor-oss/core/types";
+
+export type RoleRequirement = DashboardRole;
+
+const ROLE_WEIGHT: Record<DashboardRole, number> = {
+  viewer: 0,
+  operator: 1,
+  admin: 2,
+};
+
+function normalizeList(values: string[] | undefined): string[] {
+  return (values ?? [])
+    .map((value) => value.trim().toLowerCase())
+    .filter(Boolean);
+}
+
+function roleBindingsConfigured(bindings?: DashboardRoleBindings | null): boolean {
+  if (!bindings) return false;
+  return (
+    normalizeList(bindings.viewers).length > 0 ||
+    normalizeList(bindings.operators).length > 0 ||
+    normalizeList(bindings.admins).length > 0 ||
+    normalizeList(bindings.viewerDomains).length > 0 ||
+    normalizeList(bindings.operatorDomains).length > 0 ||
+    normalizeList(bindings.adminDomains).length > 0
+  );
+}
+
+function matchesDomain(email: string, domains: string[]): boolean {
+  return domains.some((domain) => email.endsWith(`@${domain}`));
+}
+
+function matchesEmailOrDomain(email: string, emails: string[], domains: string[]): boolean {
+  return emails.includes(email) || matchesDomain(email, domains);
+}
+
+export function isLoopbackHost(hostname: string | null | undefined): boolean {
+  const normalized = (hostname ?? "").trim().toLowerCase();
+  return normalized === "localhost"
+    || normalized === "127.0.0.1"
+    || normalized === "0.0.0.0"
+    || normalized === "::1"
+    || normalized === "[::1]";
+}
+
+export function roleMeetsRequirement(
+  actualRole: DashboardRole,
+  requiredRole: RoleRequirement,
+): boolean {
+  return ROLE_WEIGHT[actualRole] >= ROLE_WEIGHT[requiredRole];
+}
+
+export function resolveRoleForEmail(
+  email: string,
+  access: DashboardAccessConfig | null | undefined,
+  envFallback?: {
+    allowedEmails?: string[];
+    allowedDomains?: string[];
+    adminEmails?: string[];
+  },
+): {
+  role: DashboardRole | null;
+  matchedBinding: boolean;
+  explicitBindingsConfigured: boolean;
+} {
+  const normalizedEmail = email.trim().toLowerCase();
+  const bindings = access?.roles;
+
+  const adminEmails = [
+    ...normalizeList(bindings?.admins),
+    ...normalizeList(envFallback?.adminEmails),
+  ];
+  const operatorEmails = [
+    ...normalizeList(bindings?.operators),
+    ...normalizeList(envFallback?.allowedEmails),
+  ];
+  const viewerEmails = normalizeList(bindings?.viewers);
+
+  const adminDomains = normalizeList(bindings?.adminDomains);
+  const operatorDomains = [
+    ...normalizeList(bindings?.operatorDomains),
+    ...normalizeList(envFallback?.allowedDomains),
+  ];
+  const viewerDomains = normalizeList(bindings?.viewerDomains);
+
+  const explicitBindingsConfigured =
+    roleBindingsConfigured(bindings) ||
+    adminEmails.length > 0 ||
+    operatorEmails.length > 0 ||
+    operatorDomains.length > 0;
+
+  if (matchesEmailOrDomain(normalizedEmail, adminEmails, adminDomains)) {
+    return { role: "admin", matchedBinding: true, explicitBindingsConfigured };
+  }
+  if (matchesEmailOrDomain(normalizedEmail, operatorEmails, operatorDomains)) {
+    return { role: "operator", matchedBinding: true, explicitBindingsConfigured };
+  }
+  if (matchesEmailOrDomain(normalizedEmail, viewerEmails, viewerDomains)) {
+    return { role: "viewer", matchedBinding: true, explicitBindingsConfigured };
+  }
+
+  if (access?.defaultRole) {
+    return { role: access.defaultRole, matchedBinding: false, explicitBindingsConfigured };
+  }
+
+  if (explicitBindingsConfigured) {
+    return { role: null, matchedBinding: false, explicitBindingsConfigured };
+  }
+
+  return { role: "operator", matchedBinding: false, explicitBindingsConfigured };
+}