conductor-oss 0.2.15 → 0.2.16

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

@@ -0,0 +1,155 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import type { RuntimeAgentModelCatalog } from "@/lib/runtimeAgentModelsShared";
+
+export interface Agent {
+  name: string;
+  description: string;
+  installed?: boolean;
+  configured?: boolean;
+  ready?: boolean;
+  binary?: string;
+  model?: string;
+  homepage?: string;
+  iconUrl?: string;
+  runtimeModelCatalog?: RuntimeAgentModelCatalog | null;
+}
+
+interface UseAgentsReturn {
+  agents: Agent[];
+  loading: boolean;
+}
+
+type AgentsStoreSnapshot = {
+  agents: Agent[];
+  loading: boolean;
+};
+
+const AGENTS_STALE_AFTER_MS = 30_000;
+const AGENTS_RETRY_DELAY_MS = 10_000;
+
+const listeners = new Set<() => void>();
+let storeAgents: Agent[] = [];
+let storeLoading = true;
+let storeLastFetchedAt = 0;
+let storeInFlight: Promise<void> | null = null;
+let storeRetryTimeout: number | null = null;
+
+function normalizeAgentsPayload(payload: unknown): Agent[] {
+  if (Array.isArray(payload)) return payload as Agent[];
+
+  if (
+    payload &&
+    typeof payload === "object" &&
+    "agents" in payload &&
+    Array.isArray((payload as { agents?: unknown }).agents)
+  ) {
+    return (payload as { agents: Agent[] }).agents;
+  }
+
+  return [];
+}
+
+function emitChange() {
+  for (const listener of listeners) {
+    listener();
+  }
+}
+
+function currentSnapshot(): AgentsStoreSnapshot {
+  return {
+    agents: storeAgents,
+    loading: storeLoading,
+  };
+}
+
+function isStoreFresh() {
+  return storeAgents.length > 0 && Date.now() - storeLastFetchedAt < AGENTS_STALE_AFTER_MS;
+}
+
+function scheduleRetry() {
+  if (storeRetryTimeout !== null) return;
+  storeRetryTimeout = window.setTimeout(() => {
+    storeRetryTimeout = null;
+    void refreshAgents(true);
+  }, AGENTS_RETRY_DELAY_MS);
+}
+
+async function refreshAgents(force = false): Promise<void> {
+  if (!force && isStoreFresh()) {
+    if (storeLoading) {
+      storeLoading = false;
+      emitChange();
+    }
+    return;
+  }
+
+  if (storeInFlight) {
+    return storeInFlight;
+  }
+
+  storeLoading = true;
+  emitChange();
+
+  storeInFlight = (async () => {
+    try {
+      const res = await fetch("/api/agents", { cache: "no-store" });
+      if (!res.ok) throw new Error(`Failed to fetch agents: ${res.status}`);
+      const data = (await res.json()) as unknown;
+      const nextAgents = normalizeAgentsPayload(data);
+      if (nextAgents.length > 0) {
+        storeAgents = nextAgents;
+        storeLastFetchedAt = Date.now();
+        if (storeRetryTimeout !== null) {
+          window.clearTimeout(storeRetryTimeout);
+          storeRetryTimeout = null;
+        }
+      } else {
+        scheduleRetry();
+      }
+    } catch {
+      scheduleRetry();
+    } finally {
+      storeLoading = false;
+      storeInFlight = null;
+      emitChange();
+    }
+  })();
+
+  return storeInFlight;
+}
+
+export function useAgents(): UseAgentsReturn {
+  const [snapshot, setSnapshot] = useState<AgentsStoreSnapshot>(() => currentSnapshot());
+
+  useEffect(() => {
+    const applySnapshot = () => setSnapshot(currentSnapshot());
+    listeners.add(applySnapshot);
+    applySnapshot();
+    void refreshAgents();
+
+    const handleWindowFocus = () => {
+      if (!isStoreFresh()) {
+        void refreshAgents(true);
+      }
+    };
+
+    const handleVisibilityChange = () => {
+      if (document.visibilityState === "visible" && !isStoreFresh()) {
+        void refreshAgents(true);
+      }
+    };
+
+    window.addEventListener("focus", handleWindowFocus);
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+
+    return () => {
+      listeners.delete(applySnapshot);
+      window.removeEventListener("focus", handleWindowFocus);
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+    };
+  }, []);
+
+  return snapshot;
+}

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

@@ -0,0 +1,116 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+
+export interface ConfigProject {
+  id: string;
+  repo: string | null;
+  path: string | null;
+  iconUrl: string | null;
+  boardDir?: string | null;
+  boardFile?: string | null;
+  description: string | null;
+  defaultBranch: string;
+  agent: string;
+  agentPermissions: string | null;
+  agentModel: string | null;
+  agentReasoningEffort: string | null;
+}
+
+interface UseConfigReturn {
+  projects: ConfigProject[];
+  loading: boolean;
+  error: string | null;
+  refresh: () => Promise<void>;
+}
+
+function normalizeProject(
+  id: string,
+  raw: Record<string, unknown> | null,
+): ConfigProject {
+  return {
+    id,
+    repo: typeof raw?.["repo"] === "string" ? raw["repo"] : null,
+    path: typeof raw?.["path"] === "string" ? raw["path"] : null,
+    iconUrl: typeof raw?.["iconUrl"] === "string" ? raw["iconUrl"] : null,
+    boardDir: typeof raw?.["boardDir"] === "string" ? raw["boardDir"] : null,
+    boardFile: typeof raw?.["boardFile"] === "string" ? raw["boardFile"] : null,
+    description: typeof raw?.["description"] === "string" ? raw["description"] : null,
+    defaultBranch: typeof raw?.["defaultBranch"] === "string" && raw["defaultBranch"].trim().length > 0
+      ? raw["defaultBranch"]
+      : "main",
+    agent: typeof raw?.["agent"] === "string" && raw["agent"].trim().length > 0
+      ? raw["agent"]
+      : "claude-code",
+    agentPermissions: typeof raw?.["agentPermissions"] === "string" && raw["agentPermissions"].trim().length > 0
+      ? raw["agentPermissions"]
+      : null,
+    agentModel: typeof raw?.["agentModel"] === "string" && raw["agentModel"].trim().length > 0
+      ? raw["agentModel"]
+      : null,
+    agentReasoningEffort: typeof raw?.["agentReasoningEffort"] === "string" && raw["agentReasoningEffort"].trim().length > 0
+      ? raw["agentReasoningEffort"]
+      : null,
+  };
+}
+
+function normalizeProjects(payload: unknown): ConfigProject[] {
+  if (!payload || typeof payload !== "object") return [];
+
+  const projectsPayload = (payload as { projects?: unknown }).projects;
+  if (!projectsPayload) return [];
+
+  if (Array.isArray(projectsPayload)) {
+    return projectsPayload
+      .map((item, index) => {
+        if (!item || typeof item !== "object") {
+          return normalizeProject(`project-${index + 1}`, null);
+        }
+        const raw = item as Record<string, unknown>;
+        const id = typeof raw["id"] === "string" && raw["id"].trim().length > 0
+          ? raw["id"]
+          : `project-${index + 1}`;
+        return normalizeProject(id, raw);
+      });
+  }
+
+  if (typeof projectsPayload === "object") {
+    return Object.entries(projectsPayload as Record<string, unknown>)
+      .map(([id, item]) => normalizeProject(
+        id,
+        item && typeof item === "object" ? (item as Record<string, unknown>) : null,
+      ));
+  }
+
+  return [];
+}
+
+export function useConfig(): UseConfigReturn {
+  const [projects, setProjects] = useState<ConfigProject[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const fetchedRef = useRef(false);
+
+  const fetchConfig = useCallback(async () => {
+    try {
+      const res = await fetch("/api/config");
+      if (!res.ok) throw new Error(`Failed to fetch config: ${res.status}`);
+      const payload = (await res.json()) as unknown;
+      setProjects(normalizeProjects(payload));
+      setError(null);
+    } catch (err) {
+      setProjects([]);
+      setError(err instanceof Error ? err.message : "Failed to fetch config");
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    if (fetchedRef.current) return;
+    fetchedRef.current = true;
+    fetchConfig();
+  }, [fetchConfig]);
+
+  return { projects, loading, error, refresh: fetchConfig };
+}

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

@@ -0,0 +1,95 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+
+export interface UserPreferencesResponse {
+  onboardingAcknowledged: boolean;
+  codingAgent: string;
+  ide: string;
+  remoteSshHost: string;
+  remoteSshUser: string;
+  markdownEditor: string;
+  notifications: {
+    soundEnabled: boolean;
+    soundFile: string | null;
+  };
+}
+
+function toObject(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return { ...(value as Record<string, unknown>) };
+}
+
+function normalizePreferences(value: unknown): UserPreferencesResponse {
+  const payload = toObject(value);
+  const notifications = toObject(payload["notifications"]);
+  const soundFileRaw = notifications["soundFile"];
+
+  return {
+    onboardingAcknowledged: payload["onboardingAcknowledged"] === true,
+    codingAgent: typeof payload["codingAgent"] === "string" && payload["codingAgent"].trim().length > 0
+      ? payload["codingAgent"].trim()
+      : "claude-code",
+    ide: typeof payload["ide"] === "string" && payload["ide"].trim().length > 0
+      ? payload["ide"].trim()
+      : "vscode",
+    remoteSshHost: typeof payload["remoteSshHost"] === "string" && payload["remoteSshHost"].trim().length > 0
+      ? payload["remoteSshHost"].trim()
+      : "",
+    remoteSshUser: typeof payload["remoteSshUser"] === "string" && payload["remoteSshUser"].trim().length > 0
+      ? payload["remoteSshUser"].trim()
+      : "",
+    markdownEditor: typeof payload["markdownEditor"] === "string" && payload["markdownEditor"].trim().length > 0
+      ? payload["markdownEditor"].trim()
+      : "obsidian",
+    notifications: {
+      soundEnabled: notifications["soundEnabled"] !== false,
+      soundFile: soundFileRaw === null
+        ? null
+        : typeof soundFileRaw === "string" && soundFileRaw.trim().length > 0
+          ? soundFileRaw.trim()
+          : "abstract-sound-4",
+    },
+  };
+}
+
+interface UsePreferencesReturn {
+  preferences: UserPreferencesResponse | null;
+  loading: boolean;
+  error: string | null;
+  refresh: () => Promise<void>;
+}
+
+export function usePreferences(): UsePreferencesReturn {
+  const [preferences, setPreferences] = useState<UserPreferencesResponse | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const fetchedRef = useRef(false);
+
+  const fetchPreferences = useCallback(async () => {
+    try {
+      const res = await fetch("/api/preferences");
+      const data = (await res.json().catch(() => null)) as
+        | { preferences?: unknown; error?: string }
+        | null;
+      if (!res.ok) {
+        throw new Error(data?.error ?? `Failed to load preferences: ${res.status}`);
+      }
+      setPreferences(normalizePreferences(data?.preferences));
+      setError(null);
+    } catch (err) {
+      setPreferences(null);
+      setError(err instanceof Error ? err.message : "Failed to load preferences");
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    if (fetchedRef.current) return;
+    fetchedRef.current = true;
+    void fetchPreferences();
+  }, [fetchPreferences]);
+
+  return { preferences, loading, error, refresh: fetchPreferences };
+}

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

@@ -0,0 +1,191 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import { subscribeToSnapshotEvents } from "@/lib/liveEvents";
+import { TERMINAL_STATUSES, type DashboardSession, type SSESnapshotEvent } from "@/lib/types";
+
+const ACTIVE_FALLBACK_POLL_INTERVAL_MS = 10_000;
+const TERMINAL_FALLBACK_POLL_INTERVAL_MS = 30_000;
+
+interface UseSessionReturn {
+  session: DashboardSession | null;
+  loading: boolean;
+  error: string | null;
+}
+
+function sessionsEqual(left: DashboardSession | null, right: DashboardSession | null): boolean {
+  if (left === right) return true;
+  if (!left || !right) return false;
+  if (
+    left.id !== right.id ||
+    left.projectId !== right.projectId ||
+    left.status !== right.status ||
+    left.activity !== right.activity ||
+    left.branch !== right.branch ||
+    left.issueId !== right.issueId ||
+    left.summary !== right.summary ||
+    left.createdAt !== right.createdAt ||
+    left.lastActivityAt !== right.lastActivityAt
+  ) {
+    return false;
+  }
+
+  const leftMetadataKeys = Object.keys(left.metadata);
+  const rightMetadataKeys = Object.keys(right.metadata);
+  if (leftMetadataKeys.length !== rightMetadataKeys.length) return false;
+  for (const key of leftMetadataKeys) {
+    if (left.metadata[key] !== right.metadata[key]) return false;
+  }
+
+  if (left.pr === right.pr) return true;
+  if (!left.pr || !right.pr) return false;
+  return (
+    left.pr.number === right.pr.number &&
+    left.pr.url === right.pr.url &&
+    left.pr.title === right.pr.title &&
+    left.pr.branch === right.pr.branch &&
+    left.pr.baseBranch === right.pr.baseBranch &&
+    left.pr.isDraft === right.pr.isDraft &&
+    left.pr.state === right.pr.state &&
+    left.pr.ciStatus === right.pr.ciStatus &&
+    left.pr.reviewDecision === right.pr.reviewDecision &&
+    left.pr.previewUrl === right.pr.previewUrl &&
+    left.pr.mergeability.mergeable === right.pr.mergeability.mergeable &&
+    left.pr.mergeability.ciPassing === right.pr.mergeability.ciPassing &&
+    left.pr.mergeability.approved === right.pr.mergeability.approved &&
+    left.pr.mergeability.noConflicts === right.pr.mergeability.noConflicts &&
+    left.pr.mergeability.blockers.length === right.pr.mergeability.blockers.length &&
+    left.pr.mergeability.blockers.every((blocker, index) => blocker === right.pr?.mergeability.blockers[index])
+  );
+}
+
+function mapSnapshotSession(session: SSESnapshotEvent["sessions"][number]): DashboardSession {
+  return {
+    id: session.id,
+    projectId: session.projectId,
+    status: session.status,
+    activity: session.activity,
+    branch: session.branch,
+    issueId: session.issueId,
+    summary: session.summary ?? null,
+    createdAt: session.createdAt,
+    lastActivityAt: session.lastActivityAt,
+    pr: session.pr ?? null,
+    metadata: session.metadata,
+  };
+}
+
+export function useSession(id: string): UseSessionReturn {
+  const [session, setSession] = useState<DashboardSession | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const mountedRef = useRef(true);
+  const notFoundRef = useRef(false);
+  const terminalRef = useRef(false);
+  const snapshotSignatureRef = useRef<string | null>(null);
+
+  const fetchSession = useCallback(async () => {
+    if (!id || notFoundRef.current || terminalRef.current) return;
+    try {
+      const res = await fetch(`/api/sessions/${encodeURIComponent(id)}`);
+      if (res.status === 404) {
+        if (!mountedRef.current) return;
+        notFoundRef.current = true;
+        setSession(null);
+        setError(null);
+        return;
+      }
+      if (!res.ok) throw new Error(`Failed to fetch session: ${res.status}`);
+      const data: DashboardSession = await res.json();
+      if (mountedRef.current) {
+        setSession((current) => (sessionsEqual(current, data) ? current : data));
+        setError(null);
+        if (typeof data.status === "string" && TERMINAL_STATUSES.has(data.status)) {
+          terminalRef.current = true;
+        }
+      }
+    } catch (err) {
+      if (mountedRef.current) setError(err instanceof Error ? err.message : "Unknown error");
+    } finally {
+      if (mountedRef.current) setLoading(false);
+    }
+  }, [id]);
+
+  useEffect(() => {
+    mountedRef.current = true;
+    notFoundRef.current = false;
+    terminalRef.current = false;
+    snapshotSignatureRef.current = null;
+    setSession(null);
+    setError(null);
+    setLoading(true);
+    void fetchSession();
+    const unsubscribe = subscribeToSnapshotEvents((event: SSESnapshotEvent) => {
+      if (!mountedRef.current) return;
+      const matchingSession = event.sessions.find((value) => value.id === id);
+      const signature = matchingSession
+        ? [
+          matchingSession.id,
+          matchingSession.status,
+          matchingSession.activity ?? "",
+          matchingSession.lastActivityAt,
+          matchingSession.summary ?? "",
+        ].join(":")
+        : "missing";
+      if (snapshotSignatureRef.current === signature) {
+        return;
+      }
+      snapshotSignatureRef.current = signature;
+      if (!matchingSession) {
+        return;
+      }
+      notFoundRef.current = false;
+      terminalRef.current = TERMINAL_STATUSES.has(matchingSession.status);
+      const nextSession = mapSnapshotSession(matchingSession);
+      setSession((current) => (sessionsEqual(current, nextSession) ? current : nextSession));
+      setError(null);
+      setLoading(false);
+    });
+
+    let timeoutId: number | null = null;
+    const scheduleFallbackFetch = () => {
+      const delay = terminalRef.current
+        ? TERMINAL_FALLBACK_POLL_INTERVAL_MS
+        : ACTIVE_FALLBACK_POLL_INTERVAL_MS;
+      timeoutId = window.setTimeout(async () => {
+        await fetchSession();
+        if (mountedRef.current && !notFoundRef.current) {
+          scheduleFallbackFetch();
+        }
+      }, delay);
+    };
+    scheduleFallbackFetch();
+
+    const refresh = () => {
+      notFoundRef.current = false;
+      snapshotSignatureRef.current = null;
+      void fetchSession();
+    };
+
+    const handleVisibilityChange = () => {
+      if (document.visibilityState === "visible") {
+        refresh();
+      }
+    };
+
+    window.addEventListener("focus", refresh);
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+
+    return () => {
+      mountedRef.current = false;
+      unsubscribe();
+      if (timeoutId != null) {
+        window.clearTimeout(timeoutId);
+      }
+      window.removeEventListener("focus", refresh);
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+    };
+  }, [fetchSession]);
+
+  return { session, loading, error };
+}