mirror of
https://github.com/stablyai/orca.git
synced 2026-11-19 04:23:57 +00:00
* refactor(mobile): give relay and encryption concrete owners * refactor(mobile): organize session and review feature owners * refactor(mobile): organize RPC and host ownership * test(mobile): point render fixtures at concrete owners * refactor(mobile): use explicit type-only owner imports
215 lines
6.8 KiB
TypeScript
215 lines
6.8 KiB
TypeScript
import { normalizeBrowserUrl } from '../browser/browser-url'
|
|
import { translate } from '../i18n/mobile-i18n'
|
|
import { captureMobileFileMutationOwnership } from '../files/mobile-file-mutation-ownership'
|
|
import {
|
|
browserGoBack,
|
|
browserGoForward,
|
|
browserReload
|
|
} from '../browser/mobile-browser-command-operations'
|
|
import { sourceFileOpenRun } from '../source-control/mobile-source-file-open-operations'
|
|
import { sessionBrowserTabCreate } from '../browser/mobile-session-browser-operations'
|
|
import { sessionMarkdownNoteCreate } from '../files/session-documents/mobile-markdown-tab-operations'
|
|
import { interpretOrThrowRefusalMessage } from '../transport/rpc/rpc-refusal-message'
|
|
import type { MobileBrowserNavigationMethod } from './tabs/MobileBrowserTabActionSheet'
|
|
import { isFileExistsErrorMessage } from '../files/file-exists-error'
|
|
import type { MobileSessionTab } from './tabs/mobile-session-tabs'
|
|
import type { MobileSessionTerminalCreateActionsModel } from '../terminal/session/use-mobile-session-terminal-create-actions'
|
|
|
|
const BROWSER_NAVIGATION_COMMANDS = {
|
|
'browser.back': browserGoBack,
|
|
'browser.forward': browserGoForward,
|
|
'browser.reload': browserReload
|
|
} as const
|
|
|
|
export function useMobileSessionContentCreateActions(
|
|
scope: MobileSessionTerminalCreateActionsModel
|
|
) {
|
|
const {
|
|
worktreeId,
|
|
client,
|
|
creatingBrowser,
|
|
setCreatingBrowser,
|
|
creatingMarkdown,
|
|
setCreatingMarkdown,
|
|
setCreateError,
|
|
pendingBrowserFocusPageIdRef,
|
|
handleCreateBrowserRef,
|
|
browserScreencastSupportedRef,
|
|
scheduleDelayedAction,
|
|
showToast,
|
|
fetchSessionTabs,
|
|
fetchPendingBrowserSessionTabs
|
|
} = scope
|
|
async function handleCreateMarkdownNote() {
|
|
if (!client || creatingMarkdown) {
|
|
return
|
|
}
|
|
|
|
setCreatingMarkdown(true)
|
|
setCreateError('')
|
|
|
|
try {
|
|
const worktree = `id:${worktreeId}`
|
|
const mutationOwnership = await captureMobileFileMutationOwnership(client, worktree)
|
|
for (let attempt = 1; attempt <= 100; attempt += 1) {
|
|
const relativePath = attempt === 1 ? 'untitled.md' : `untitled-${attempt}.md`
|
|
const createResponse = await sessionMarkdownNoteCreate.request(
|
|
client,
|
|
{ worktree, relativePath, ...mutationOwnership },
|
|
{ timeoutMs: 15_000 }
|
|
)
|
|
if (!createResponse.ok) {
|
|
const message = createResponse.error.message
|
|
if (isFileExistsErrorMessage(message) && attempt < 100) {
|
|
continue
|
|
}
|
|
throw new Error(
|
|
message ||
|
|
translate(
|
|
'session.useContentCreateActions.noteCreateFailed',
|
|
'Failed to create markdown note'
|
|
)
|
|
)
|
|
}
|
|
|
|
const openResponse = await sourceFileOpenRun.request(
|
|
client,
|
|
{ worktree, relativePath },
|
|
{ timeoutMs: 15_000 }
|
|
)
|
|
interpretOrThrowRefusalMessage(() => sourceFileOpenRun.interpret(openResponse), '')
|
|
scheduleDelayedAction(() => void fetchSessionTabs(), 300)
|
|
return
|
|
}
|
|
throw new Error(
|
|
translate(
|
|
'session.useContentCreateActions.untitledNoteCreateFailed',
|
|
'Unable to create untitled markdown note'
|
|
)
|
|
)
|
|
} catch (err) {
|
|
const message =
|
|
err instanceof Error
|
|
? err.message
|
|
: translate(
|
|
'session.useContentCreateActions.noteCreateFailed',
|
|
'Failed to create markdown note'
|
|
)
|
|
setCreateError(message)
|
|
showToast(message, 1800)
|
|
} finally {
|
|
setCreatingMarkdown(false)
|
|
}
|
|
}
|
|
|
|
async function handleCreateBrowser(rawUrl = 'about:blank'): Promise<boolean> {
|
|
if (!client || creatingBrowser) {
|
|
return false
|
|
}
|
|
// Read capability via ref so pre-probe taps and old callbacks see the current host facts.
|
|
if (browserScreencastSupportedRef.current !== true) {
|
|
showToast(
|
|
translate(
|
|
'session.useContentCreateActions.browserUpdateRequired',
|
|
'Desktop update required for mobile browser streaming'
|
|
),
|
|
1600
|
|
)
|
|
return false
|
|
}
|
|
const url = normalizeBrowserUrl(rawUrl)
|
|
if (!url) {
|
|
const message = translate('session.useContentCreateActions.invalidUrl', 'Enter a valid URL')
|
|
setCreateError(message)
|
|
showToast(message, 1400)
|
|
return false
|
|
}
|
|
|
|
setCreatingBrowser(true)
|
|
setCreateError('')
|
|
try {
|
|
const response = await sessionBrowserTabCreate.request(
|
|
client,
|
|
{
|
|
worktree: `id:${worktreeId}`,
|
|
url,
|
|
activate: true
|
|
},
|
|
{ timeoutMs: 30_000 }
|
|
)
|
|
const created = interpretOrThrowRefusalMessage(
|
|
() => sessionBrowserTabCreate.interpret(response),
|
|
''
|
|
)
|
|
// Poll briefly for async host registration before focusing the new browser tab.
|
|
if (created.browserPageId) {
|
|
pendingBrowserFocusPageIdRef.current = created.browserPageId
|
|
}
|
|
void fetchSessionTabs()
|
|
scheduleDelayedAction(() => void fetchPendingBrowserSessionTabs(), 400)
|
|
scheduleDelayedAction(() => void fetchPendingBrowserSessionTabs(), 1200)
|
|
return true
|
|
} catch (err) {
|
|
const message =
|
|
err instanceof Error
|
|
? err.message
|
|
: translate(
|
|
'session.useContentCreateActions.browserCreateFailed',
|
|
'Failed to create browser'
|
|
)
|
|
setCreateError(message)
|
|
showToast(message, 1800)
|
|
return false
|
|
} finally {
|
|
setCreatingBrowser(false)
|
|
}
|
|
}
|
|
handleCreateBrowserRef.current = handleCreateBrowser
|
|
|
|
async function handleBrowserNavigationCommand(
|
|
tab: Extract<MobileSessionTab, { type: 'browser' }>,
|
|
method: MobileBrowserNavigationMethod
|
|
) {
|
|
if (!client || !tab.browserPageId) {
|
|
showToast(
|
|
translate(
|
|
'session.useContentCreateActions.browserUnavailable',
|
|
'Browser page is not available yet.'
|
|
),
|
|
1500
|
|
)
|
|
return
|
|
}
|
|
try {
|
|
const command = BROWSER_NAVIGATION_COMMANDS[method]
|
|
const response = await command.request(
|
|
client,
|
|
{
|
|
worktree: `id:${worktreeId}`,
|
|
page: tab.browserPageId
|
|
},
|
|
{ timeoutMs: 15_000 }
|
|
)
|
|
interpretOrThrowRefusalMessage(() => command.interpret(response), '')
|
|
scheduleDelayedAction(() => void fetchSessionTabs(), 250)
|
|
} catch (err) {
|
|
const message =
|
|
err instanceof Error
|
|
? err.message
|
|
: translate(
|
|
'session.useContentCreateActions.browserCommandFailed',
|
|
'Browser command failed'
|
|
)
|
|
showToast(message, 1600)
|
|
}
|
|
}
|
|
return {
|
|
handleCreateMarkdownNote,
|
|
handleCreateBrowser,
|
|
handleBrowserNavigationCommand
|
|
}
|
|
}
|
|
|
|
export type MobileSessionContentCreateActionsModel = MobileSessionTerminalCreateActionsModel &
|
|
ReturnType<typeof useMobileSessionContentCreateActions>
|