Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
8.8 KB
Raw Blame
// Pending interactions for a conversation and its descendants. Requests stay
// owned by the session that asked; only their presentation bubbles to the parent.
import { useCallback, useEffect, useMemo, useRef, useState } from "react";
import { toast } from "sonner";

import { unwrap } from "@/app/lib/opencode";
import { isOpencodeV2Client } from "@/app/lib/opencode-v2-adapter";
import type { Client, PendingPermission, PendingQuestion, TodoItem } from "@/app/types";
import { t } from "@/i18n";
import { useQueryCacheArrayState, useQueryCacheState } from "@/react-app/infra/query-cache-state";
import { describeRouteError } from "@/react-app/shell/route-workspaces";
import {
  permissionKey,
  questionKey,
  seedPermissionState,
  seedQuestionState,
  settleQuestionState,
  settlePermissionState,
  todoKey,
} from "./session-sync";

const emptyPendingPermissions: PendingPermission[] = [];
const emptyPendingQuestions: PendingQuestion[] = [];
const emptyTodos: TodoItem[] = [];

export type UseSessionInteractionsInput = {
  client: Client | null;
  workspaceId: string;
  sessionId: string | null;
  interactionSessionIds?: string[];
  workspaceRoot: string;
};

export function useSessionInteractions(input: UseSessionInteractionsInput) {
  const { client, workspaceId, sessionId, workspaceRoot } = input;

  const [permissionReplyBusy, setPermissionReplyBusy] = useState(false);
  const permissionReplyBusyRef = useRef(false);
  const [questionReplyBusy, setQuestionReplyBusy] = useState(false);
  const questionReplyBusyRef = useRef(false);

  const requestedSessionIdsKey = (input.interactionSessionIds ?? []).join("\u0000");
  const interactionSessionIds = useMemo(() => {
    if (!sessionId) return [];
    const requested = requestedSessionIdsKey ? requestedSessionIdsKey.split("\u0000") : [];
    return Array.from(new Set([sessionId, ...requested].map((id) => id.trim()).filter(Boolean)));
  }, [requestedSessionIdsKey, sessionId]);
  const permissionQueryKeys = useMemo(
    () => workspaceId ? interactionSessionIds.map((id) => permissionKey(workspaceId, id)) : [],
    [interactionSessionIds, workspaceId],
  );
  const cachedPermissions = useQueryCacheArrayState<PendingPermission>(
    permissionQueryKeys,
    emptyPendingPermissions,
  );
  const pendingPermissions = useMemo(
    () => [...cachedPermissions].sort((left, right) => left.receivedAt - right.receivedAt || left.id.localeCompare(right.id)),
    [cachedPermissions],
  );
  const questionQueryKeys = useMemo(
    () => workspaceId ? interactionSessionIds.map((id) => questionKey(workspaceId, id)) : [],
    [interactionSessionIds, workspaceId],
  );
  const cachedQuestions = useQueryCacheArrayState<PendingQuestion>(
    questionQueryKeys,
    emptyPendingQuestions,
  );
  const pendingQuestions = useMemo(
    () => [...cachedQuestions].sort((left, right) => left.receivedAt - right.receivedAt || left.id.localeCompare(right.id)),
    [cachedQuestions],
  );
  const todoQueryKey = useMemo(
    () => (workspaceId && sessionId ? todoKey(workspaceId, sessionId) : null),
    [sessionId, workspaceId],
  );
  const todos = useQueryCacheState<TodoItem[]>(todoQueryKey, emptyTodos);

  useEffect(() => {
    if (!client || !workspaceId || interactionSessionIds.length === 0) return;
    const controller = new AbortController();
    const directory = workspaceRoot || undefined;
    void (async () => {
      const snapshotStartedAt = Date.now();
      try {
        let legacyPermissions: Parameters<typeof seedPermissionState>[2] = [];
        let legacyReadSucceeded = false;
        // The v2 compatibility list sweeps every session; the scoped reads below
        // already return its native requests. V1 still needs both protocols.
        if (!isOpencodeV2Client(client)) {
          try {
            legacyPermissions = unwrap(await client.permission.list({ directory }, { signal: controller.signal }));
            legacyReadSucceeded = true;
          } catch {
            // Older/newer OpenCode permission APIs can fail independently.
          }
        }
        if (controller.signal.aborted) return;

        const v2Reads = await Promise.all(interactionSessionIds.map(async (permissionSessionId) => {
          try {
            const permissions = unwrap(
              await client.v2.session.permission.list({ sessionID: permissionSessionId }, { signal: controller.signal }),
            ).data;
            return { permissionSessionId, permissions, succeeded: true };
          } catch {
            return { permissionSessionId, permissions: [], succeeded: false };
          }
        }));

        if (controller.signal.aborted) return;
        for (const read of v2Reads) {
          if (!legacyReadSucceeded && !read.succeeded) continue;
          seedPermissionState(
            workspaceId,
            read.permissionSessionId,
            [...legacyPermissions, ...read.permissions],
            { snapshotStartedAt },
          );
        }
      } catch {
        // Keep event-synced permission state if the snapshot read fails.
        // Hiding a pending approval can block the running task.
      }
    })();
    return () => {
      controller.abort();
    };
  }, [client, interactionSessionIds, workspaceId, workspaceRoot]);

  useEffect(() => {
    if (!client || !workspaceId || interactionSessionIds.length === 0) return;
    const controller = new AbortController();
    const directory = workspaceRoot || undefined;
    void (async () => {
      const snapshotStartedAt = Date.now();
      try {
        const list = unwrap(await client.question.list({ directory }, { signal: controller.signal }));
        if (controller.signal.aborted) return;
        for (const questionSessionId of interactionSessionIds) {
          seedQuestionState(workspaceId, questionSessionId, list, { snapshotStartedAt });
        }
      } catch {
        // Keep event-synced question state if the snapshot read fails.
        // Hiding a pending question can block the running task.
      }
    })();
    return () => {
      controller.abort();
    };
  }, [client, interactionSessionIds, workspaceId, workspaceRoot]);

  const activePermission = pendingPermissions[0] ?? null;
  const respondPermission = useCallback(
    async (requestID: string, reply: "once" | "always" | "reject") => {
      if (!client || !workspaceId || !sessionId) return;
      if (permissionReplyBusyRef.current) return;
      permissionReplyBusyRef.current = true;
      setPermissionReplyBusy(true);
      try {
        const pendingPermission = pendingPermissions.find((permission) => permission.id === requestID);
        if (pendingPermission?.evaluation) {
          // A development-only proof request has no engine-side request to answer.
        } else if (pendingPermission?.protocol === "v2") {
          const result = await client.v2.session.permission.reply({
            sessionID: pendingPermission.sessionID,
            requestID,
            reply,
          });
          if (result.error !== undefined) unwrap(result);
        } else {
          unwrap(
            await client.permission.reply({
              requestID,
              reply,
              directory: workspaceRoot || undefined,
            }),
          );
        }
        if (pendingPermission) {
          settlePermissionState(workspaceId, pendingPermission.sessionID, requestID);
        }
      } catch (error) {
        toast.error(t("app.error_request_failed"), {
          description: describeRouteError(error),
        });
      } finally {
        permissionReplyBusyRef.current = false;
        setPermissionReplyBusy(false);
      }
    },
    [client, pendingPermissions, interactionSessionIds, sessionId, workspaceId, workspaceRoot],
  );

  const activeQuestion = pendingQuestions[0] ?? null;
  const respondQuestion = useCallback(
    async (requestID: string, answers: string[][]) => {
      if (!client || !workspaceId || !sessionId) return;
      if (questionReplyBusyRef.current) return;
      questionReplyBusyRef.current = true;
      setQuestionReplyBusy(true);
      try {
        const pendingQuestion = pendingQuestions.find((question) => question.id === requestID);
        unwrap(
          await client.question.reply({
            requestID,
            answers,
            directory: workspaceRoot || undefined,
          }),
        );
        if (pendingQuestion) {
          settleQuestionState(workspaceId, pendingQuestion.sessionID, requestID);
        }
      } catch (error) {
        toast.error(t("app.error_request_failed"), {
          description: describeRouteError(error),
        });
      } finally {
        questionReplyBusyRef.current = false;
        setQuestionReplyBusy(false);
      }
    },
    [client, pendingQuestions, sessionId, workspaceId, workspaceRoot],
  );

  return {
    activePermission,
    permissionReplyBusy,
    respondPermission,
    activeQuestion,
    questionReplyBusy,
    respondQuestion,
    todos,
  };
}