Files
archived-orca/mobile/src/session/use-mobile-session-content-create-actions.ts
Neil 19043a3d76 refactor(mobile): organize pairing, session, RPC and host owners (#39846)
* 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
2026-11-08 07:19:05 -08:00

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>