Skip to content

armgit / orca

Public Imported from GitHub
0

Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.

8.7 KB
Raw Blame
import { useCallback } from 'react'
import { Keyboard, Platform } from 'react-native'
import { useClipboardWriter } from '../platform/clipboard'
import { translate } from '../i18n/mobile-i18n'
import { useMobileTranslation } from '../i18n/use-mobile-translation'
import { useBackClaim } from '../navigation/use-back-claim'
import { useSessionLeaveGuard } from './session-leave-guard'
import { markdownTabSave } from './mobile-session-write-operations'
import { triggerSuccess, triggerError } from '../platform/haptics'
import type { DirtyMarkdownDraft, MobileSessionTab } from './mobile-session-route-types'
import type { MobileSessionDiffCommentsModel } from './use-mobile-session-diff-comments'

// Depend on the action’s narrow scope so Back behavior can be tested without constructing the whole session model.
export type MobileSessionMarkdownActionsScope = Pick<
  MobileSessionDiffCommentsModel,
  | 'hostId'
  | 'worktreeId'
  | 'router'
  | 'client'
  | 'sessionTabs'
  | 'setMarkdownDocs'
  | 'markdownDocs'
  | 'setDiscardMarkdownTarget'
  | 'discardMarkdownTarget'
  | 'setLeaveDrafts'
  | 'markdownSaveSeqRef'
  | 'markdownSaveInFlightRef'
  | 'showToast'
  | 'readMarkdownTab'
  | 'dictationLeaveHold'
>

export function useMobileSessionMarkdownActions(scope: MobileSessionMarkdownActionsScope) {
  const t = useMobileTranslation()
  const {
    hostId,
    worktreeId,
    router,
    client,
    sessionTabs,
    setMarkdownDocs,
    markdownDocs,
    setDiscardMarkdownTarget,
    discardMarkdownTarget,
    setLeaveDrafts,
    markdownSaveSeqRef,
    markdownSaveInFlightRef,
    showToast,
    readMarkdownTab,
    dictationLeaveHold: { hold: holdLeaveForDictation, holdsLeave: dictationHoldsLeave }
  } = scope
  const clipboard = useClipboardWriter()
  const updateMarkdownLocalContent = useCallback((tabId: string, content: string) => {
    setMarkdownDocs((prev) => {
      const current = prev.get(tabId)
      if (current?.status !== 'ready') {
        return prev
      }
      const next = new Map(prev)
      next.set(tabId, {
        ...current,
        localRevision: (current.localRevision ?? 0) + 1,
        localContent: content,
        isDirty: content !== current.content,
        saveError: undefined
      })
      return next
    })
  }, [])

  const copyMarkdownLocalContent = useCallback(
    async (tabId: string) => {
      const current = markdownDocs.get(tabId)
      if (current?.status !== 'ready') {
        return
      }
      // Contain fire-and-forget clipboard refusal so Copied cannot remain as false success feedback.
      try {
        await clipboard.writeText(current.localContent)
      } catch {
        triggerError()
        showToast(translate('session.useMarkdownActions.copyFailed', "Couldn't copy"), 1500)
        return
      }
      triggerSuccess()
      showToast(translate('common.copied', 'Copied'))
    },
    [clipboard, markdownDocs, showToast]
  )

  const copyMarkdownPath = useCallback(
    async (tab: Extract<MobileSessionTab, { type: 'markdown' }>) => {
      try {
        await clipboard.writeText(tab.relativePath || tab.filePath)
        showToast(translate('session.useMarkdownActions.pathCopied', 'Path copied'))
      } catch {
        triggerError()
        showToast(
          translate('session.useMarkdownActions.copyPathFailed', "Couldn't copy path"),
          1500
        )
      }
    },
    [clipboard, showToast]
  )

  const getDirtyMarkdownDrafts = useCallback(() => {
    const drafts: DirtyMarkdownDraft[] = []
    for (const [tabId, doc] of markdownDocs) {
      if (doc.status === 'ready' && doc.isDirty) {
        const tab = sessionTabs.find((candidate) => candidate.id === tabId)
        drafts.push({
          tabId,
          title: tab?.title || t('session.useMarkdownActions.markdownTitle', 'Markdown'),
          content: doc.localContent
        })
      }
    }
    return drafts
  }, [markdownDocs, sessionTabs, t])

  const leaveSession = useCallback(() => {
    if (router.canGoBack()) {
      router.back()
      return
    }
    // Why: Android back can fire at the root route; replace avoids React Navigation's dev-only GO_BACK warning.
    router.replace(`/h/${hostId}`)
  }, [hostId, router])

  const requestLeaveSession = useCallback(() => {
    if (holdLeaveForDictation()) {
      return
    }
    const dirtyDrafts = getDirtyMarkdownDrafts()
    if (dirtyDrafts.length === 0) {
      leaveSession()
      return
    }
    Keyboard.dismiss()
    setLeaveDrafts(dirtyDrafts)
  }, [getDirtyMarkdownDrafts, holdLeaveForDictation, leaveSession])

  // Native always claims Back to avoid root exit; the web shell already pops, so only dirty drafts and dictation need a claim.
  const hasDirtyDraft = getDirtyMarkdownDrafts().length > 0
  useBackClaim(
    Platform.OS === 'web' && !hasDirtyDraft && !dictationHoldsLeave
      ? null
      : () => {
          requestLeaveSession()
          return true
        }
  )
  useSessionLeaveGuard(dictationHoldsLeave ? holdLeaveForDictation : null)

  const discardMarkdownLocalContent = useCallback(
    (tab: Extract<MobileSessionTab, { type: 'markdown' }>) => {
      const current = markdownDocs.get(tab.id)
      if (current?.status !== 'ready') {
        return
      }
      if (!current.isDirty) {
        void readMarkdownTab(tab)
        return
      }
      Keyboard.dismiss()
      setDiscardMarkdownTarget(tab)
    },
    [markdownDocs, readMarkdownTab]
  )

  const confirmDiscardMarkdown = useCallback(() => {
    const target = discardMarkdownTarget
    setDiscardMarkdownTarget(null)
    if (target) {
      void readMarkdownTab(target)
    }
  }, [discardMarkdownTarget, readMarkdownTab])

  const saveMarkdownTab = useCallback(
    async (tab: Extract<MobileSessionTab, { type: 'markdown' }>) => {
      if (!client) {
        return
      }
      const current = markdownDocs.get(tab.id)
      if (current?.status !== 'ready' || current.saving || !current.editable) {
        return
      }
      if (markdownSaveInFlightRef.current.has(tab.id)) {
        return
      }
      markdownSaveInFlightRef.current.add(tab.id)
      const saveSeq = (markdownSaveSeqRef.current.get(tab.id) ?? 0) + 1
      markdownSaveSeqRef.current.set(tab.id, saveSeq)
      setMarkdownDocs((prev) => {
        const existing = prev.get(tab.id)
        if (existing?.status !== 'ready') {
          return prev
        }
        return new Map(prev).set(tab.id, {
          ...existing,
          localRevision: (existing.localRevision ?? 0) + 1,
          saving: true,
          saveError: undefined
        })
      })
      try {
        const response = await markdownTabSave.request(client, {
          worktree: `id:${worktreeId}`,
          tabId: tab.id,
          baseVersion: current.baseVersion,
          content: current.localContent
        })
        const result = markdownTabSave.interpret(response)
        if (markdownSaveSeqRef.current.get(tab.id) !== saveSeq) {
          return
        }
        setMarkdownDocs((prev) => {
          const existing = prev.get(tab.id)
          const revision =
            existing?.status === 'ready' ? existing.localRevision : current.localRevision
          return new Map(prev).set(tab.id, {
            localRevision: (revision ?? 0) + 1,
            status: 'ready',
            content: result.content,
            localContent: result.content,
            baseVersion: result.version,
            isDirty: false,
            editable: true
          })
        })
        markdownSaveSeqRef.current.delete(tab.id)
        triggerSuccess()
        showToast(translate('session.useMarkdownActions.saved', 'Saved'))
      } catch (error) {
        triggerError()
        const message =
          error instanceof Error
            ? error.message
            : translate('session.useMarkdownActions.saveFailed', 'Save failed')
        if (markdownSaveSeqRef.current.get(tab.id) !== saveSeq) {
          return
        }
        setMarkdownDocs((prev) => {
          const existing = prev.get(tab.id)
          if (existing?.status !== 'ready') {
            return prev
          }
          return new Map(prev).set(tab.id, {
            ...existing,
            localRevision: (existing.localRevision ?? 0) + 1,
            saving: false,
            saveError: message || translate('session.useMarkdownActions.saveFailed', 'Save failed')
          })
        })
      } finally {
        markdownSaveInFlightRef.current.delete(tab.id)
      }
    },
    [client, markdownDocs, showToast, worktreeId]
  )
  return {
    updateMarkdownLocalContent,
    copyMarkdownLocalContent,
    copyMarkdownPath,
    getDirtyMarkdownDrafts,
    leaveSession,
    requestLeaveSession,
    discardMarkdownLocalContent,
    confirmDiscardMarkdown,
    saveMarkdownTab
  }
}

export type MobileSessionMarkdownActionsModel = MobileSessionDiffCommentsModel &
  ReturnType<typeof useMobileSessionMarkdownActions>