A desktop coding agent with free access to frontier models.
TypeScript
/** @jsxImportSource react */
import { isProviderLocked, providerLockAnswered, providerLockMessage, useProviderLock } from "@/app/lib/provider-lock";
import { useEditorStore } from "../domains/session/editor/editor-store";
import { isElectronRuntime } from "../../app/utils";
import {
useCallback,
useEffect,
useMemo,
useReducer,
useRef,
useState,
} from "react";
import { useLocation, useNavigate } from "react-router";
import { Archive, ArchiveRestore } from "lucide-react";
import { toast } from "@/components/ui/sonner";
import { closeWorkspaceTerminals } from "../domains/session/terminal/terminal-runtime";
import type { ProviderListResponse } from "@opencode-ai/sdk/v2/client";
import { captureAnalyticsEvent, markTaskRunStart } from "@/app/lib/analytics";
import { noteNewBuildathonProject } from "@/app/lib/buildathon";
import { trackSessionActive, trackTaskStarted } from "@/app/lib/den-telemetry";
import { buildDiagnosticsBundleJson } from "@/app/lib/diagnostics-bundle";
import { downloadTextAsFile } from "@/app/lib/download";
import { canCreateWorkspaces } from "@/app/lib/workspace-creation-policy";
import { useQueryClient } from "@tanstack/react-query";
import { isPromptAdmissionUnknown, unwrap } from "@/app/lib/opencode";
import { createClientV2 } from "@/app/lib/opencode-v2-adapter";
import { abortSessionSafe, forkSession, listCommands, revertSession, setSessionArchived, shellInSession, unrevertSession } from "@/app/lib/opencode-session";
import { getNativeSessionMessages } from "@/app/lib/opencode-session-native";
import { copySessionId } from "@/react-app/domains/session/sidebar/copy-session-id";
import { useSessionManagementStore as sessionManagementStore } from "@/react-app/domains/session/sidebar/session-management-store";
import { getSessionDescendantIds } from "@/react-app/domains/session/sidebar/utils";
import {
buildOmniRushWorkspaceBaseUrl,
readOmniRushServerSettings,
} from "@/app/lib/omnirush-server";
import {
workspaceServerId,
type ResolvedWorkspaceEndpoint,
} from "@/app/lib/workspace-endpoint";
import { buildOmniRushEnvRuntimeKey } from "@/app/lib/omnirush-env-runtime";
import {
getDesktopHomeDir,
joinDesktopPath,
revealDesktopItemInDir,
pickDirectory,
resolveWorkspaceListSelectedId,
workspaceBootstrap,
workspaceCreateRemote,
workspaceForget,
workspaceSetRuntimeActive,
workspaceSetSelected,
type OmniRushServerInfo,
type WorkspaceInfo,
type WorkspaceList,
} from "@/app/lib/desktop";
import type {
ComposerAttachment,
ComposerDraft,
ModelOption,
ModelRef,
SlashCommandOption,
WorkspacePreset,
WorkspaceConnectionState,
Client,
ProviderListItem,
PendingPermission,
WorkspaceDisplay,
WorkspaceSessionGroup,
} from "@/app/types";
import { buildFeedbackUrl } from "@/app/lib/feedback";
import { openFeedbackDialog, setFeedbackCurrentSession } from "@/app/lib/in-app-feedback";
import {
getWorkspaceTaskLoadErrorDisplay,
isDesktopRuntime,
isSandboxWorkspace,
normalizeDirectoryPath,
normalizeSessionStatus,
resolveModelDisplayName,
safeStringify,
} from "@/app/utils";
import { t } from "@/i18n";
import {
type RouteWorkspace,
type RouteSession,
describeRouteError,
describeTaskCreateFailure,
describeTaskCreateRetry,
describeWorkspaceCreateError,
createRouteSession,
deleteRouteSession,
removeRouteWorkspace,
downloadWorkspaceJson,
folderNameFromPath,
getSessionStatus,
isActiveSessionStatus,
isTransientStartupError,
mapDesktopWorkspace,
mergeRouteWorkspaces,
orderRouteWorkspaces,
TASK_CREATE_RETRY_DELAYS_MS,
toSessionGroups,
withTransientEngineRetry,
workspaceExportFilename,
workspaceLabel,
} from "@/react-app/shell/route-workspaces";
import { reloadEngineWithDesktopFallback } from "@/react-app/shell/engine-reload-escalation";
import { useLocal } from "@/react-app/kernel/local-provider";
import { projectModelKey, rememberProjectModel, useProjectModelLocal } from "./project-model-prefs";
import { usePlatform } from "@/react-app/kernel/platform";
import {
SessionPage,
type OpenSessionTab,
type SessionPagePaneRuntime,
} from "@/react-app/domains/session/chat/session-page";
import { AutomationsPage } from "@/react-app/domains/automations/automations-page";
import { isWorkModeShortcut, shownInMode, useWorkModeStore, useWorkState, WORK_CONNECTORS_ROUTE, WORK_HOME_ROUTE, WORK_KNOWLEDGE_ROUTE, WORK_PRESET, type AppMode } from "@/react-app/domains/work/work-mode";
import { WorkKnowledgePage } from "@/react-app/domains/work/knowledge-views";
import { WorkConnectorsPage, WorkHome, WorkModeToggle } from "@/react-app/domains/work/work-views";
import { AppsPage } from "@/react-app/domains/apps/apps-page";
import { DashboardPage } from "@/react-app/domains/dashboard/dashboard-page";
import { useDashboardDeploymentAvailability } from "@/react-app/domains/dashboard/dashboard-availability";
import { useAutomationDeploymentEnabled } from "@/react-app/domains/automations/automation-availability";
import { automationsStateChangedEvent } from "@/react-app/domains/automations/automation-events";
import type {
NewTaskComposerContext,
NewTaskComposerHandoff,
} from "@/react-app/domains/session/chat/new-task-composer";
import { isDesktopProviderBlocked } from "@/app/cloud/desktop-app-restrictions";
import { useCheckDesktopRestriction } from "@/react-app/domains/cloud/desktop-config-provider";
import { useRestrictionNotice } from "@/react-app/domains/cloud/restriction-notice-provider";
import { ReactSessionRuntime } from "@/react-app/domains/session/sync/runtime-sync";
import { useSessionActivityStore } from "@/react-app/domains/session/status/session-activity-store";
import { buildOmniRushSessionSystemContext } from "@/react-app/domains/session/sync/env-context";
import {
applySessionRevert,
applySessionUnrevert,
permissionKey,
} from "@/react-app/domains/session/sync/session-sync";
import { draftToParts } from "@/react-app/domains/session/sync/draft-parts";
import { useSessionInteractions } from "@/react-app/domains/session/sync/use-session-interactions";
import { useModelBehavior } from "@/react-app/domains/session/surface/use-model-behavior";
import { getModelBehaviorSummary, nextModelBehaviorValue, previousModelBehaviorValue } from "@/app/lib/model-behavior";
import { computeModelAvailability, createUnavailableConfirmationGate, sessionModelFallback, type ModelAvailability } from "@/react-app/domains/session/surface/model-availability";
import { useSessionFindStore } from "@/react-app/domains/session/surface/find-store";
import { useModelPicker } from "@/react-app/domains/session/modals/use-model-picker";
import { getSessionModelSelection, resolveSendVariant, useSessionModelStore } from "@/react-app/domains/session/surface/session-model-store";
import { chatStarted, markChatStarted, useProjectModelModes } from "@/react-app/domains/session/surface/model-modes";
import { claudeModelName, decideModelPick, isClaudeModel, newChatPrompt, setUpClaudeSandbox, useClaudeModels, useClaudeModelSync, useModelPickGate } from "@/react-app/domains/session/surface/claude-models";
import { ConfirmModal } from "@/react-app/design-system/modals/confirm-modal";
import { useWorkbenchStore } from "@/react-app/domains/session/chat/workbench-store";
import { resolveWorkbenchPaneEndpoint } from "@/react-app/domains/session/chat/pane-runtime";
import {
nextFavoriteModel,
useModelCollectionsStore,
} from "@/react-app/domains/session/models/model-collections-store";
import { openModelPickerEvent, openProviderAuthEvent } from "@/react-app/shell/new-providers-listener";
import {
composerAutoSendScopeKey,
markComposerAutoSend,
} from "@/react-app/domains/session/surface/composer-auto-send";
import { sendWithRevertRollback } from "@/react-app/domains/session/surface/safe-edit-resend";
import { assertQueuedSendCurrent, getQueuedSendGeneration } from "@/react-app/domains/session/surface/queued-drain-machine";
import { CreateRemoteWorkspaceModal } from "@/react-app/domains/workspace/create-remote-workspace-modal";
import { CreateWorkspaceModal } from "@/react-app/domains/workspace/create-workspace-modal";
import type { CreateWorkspaceOptions } from "@/react-app/domains/workspace/types";
import { isCloudManagedProviderKey } from "@/react-app/domains/connections/provider-auth/cloud-provider-config";
import { assignedModelOptions } from "@/react-app/domains/connections/provider-auth/assigned-model-options";
import {
filterEntitledModelOptions,
resolveEntitledOrgDefaultModel,
type ModelEntitlementOption,
} from "@/react-app/domains/connections/provider-auth/provider-policy";
import {
isOrganizationModelsEmpty,
shouldAutoOpenUnavailableModelPicker,
} from "@/react-app/domains/connections/provider-auth/managed-models-recovery";
import { useSessionProviderAuth } from "@/react-app/domains/connections/provider-auth/use-session-provider-auth";
import {
disabledProvidersFromConfig,
updateManagedDisabledProviders,
} from "@/react-app/domains/connections/managed-engine-config";
import { useMcpConnectedCount } from "@/react-app/domains/connections/use-mcp-connected-count";
import { useSessionMcpMaintenance } from "@/react-app/domains/connections/use-session-mcp-maintenance";
import { useCloudMcpSubmitReadiness } from "@/react-app/domains/connections/use-cloud-mcp-submit-readiness";
import {
IDLE_CLOUD_MCP_SUBMISSION_GATE_STATE,
type CloudMcpSubmissionResult,
} from "@/react-app/domains/connections/cloud-mcp-submit-readiness";
import { useRemoteAccessRestart } from "@/react-app/domains/workspace/remote-access-restart";
import { RenameWorkspaceModal } from "@/react-app/domains/workspace/rename-workspace-modal";
import { useRemoteWorkspaceConnectionEditor } from "@/react-app/domains/workspace/use-remote-workspace-connection-editor";
import { useDenAuth } from "@/react-app/domains/cloud/den-auth-provider";
import {
hasOmniRushModelsAvailable,
shouldShowOmniRushModelsSyncing,
} from "@/react-app/domains/cloud/omnirush-models-promo";
import {
diagnoseRemoteWorkspaceTaskLoadFailure,
getRemoteWorkspaceConnectionKey,
testRemoteWorkspaceConnection,
} from "@/react-app/domains/workspace/remote-workspace-diagnostics";
import { useShareWorkspaceState } from "@/react-app/domains/workspace/share-workspace-state";
import { ModelPickerModal, MODEL_PICKER_UNAVAILABLE_SUBTITLE } from "@/react-app/domains/session/modals/model-picker-modal";
import { CommandPalette, type PaletteItem, type SessionGroupOption } from "./command-palette";
import { buildCommandPaletteSessions, buildCopySessionIdPaletteItem } from "./command-palette-sessions";
import { requestRenameSession } from "./session-actions-bus";
import type { ThinkingModeShortcutDirection } from "./thinking-mode-shortcut";
import { SessionSearchDialog } from "./session-search-dialog";
import type { SessionMessageFetcher } from "@/react-app/domains/session/search/session-search";
import { useBootState } from "./boot-state";
import {
forgetWorkspaceMemory,
readLastSessionFor,
readWorkspaceProjectDimension,
readWorkspaceOrderIds,
writeActiveWorkspaceId,
writeLastSessionFor,
writeWorkspaceProjectDimension,
writeWorkspaceOrderIds,
} from "./session-memory";
import {
publishInspectorSlice,
recordInspectorEvent,
} from "../../app/lib/app-inspector";
import {
resolveSessionDraftScope,
saveSessionDraft,
sessionDraftScopeKey,
} from "@/react-app/domains/session/sync/draft-store";
import {
claimComposerSessionDraftScope,
persistableComposerDraftText,
snapshotComposerSessionState,
useComposerStateStore,
} from "@/react-app/domains/session/surface/composer-state-store";
import { useControlAction, type OmniRushControlAction } from "./control/control-provider";
import { useReactRenderWatchdog } from "./react-render-watchdog";
import { useBootOverlayVisible } from "./boot-state";
import {
createDenClient,
isDenOrgAdminRole,
readDenSettings,
type DenOrgRole,
} from "@/app/lib/den";
import { denSessionUpdatedEvent, denSettingsChangedEvent } from "@/app/lib/den-session-events";
import { filterProviderList } from "@/app/utils/providers";
import { ensureDesktopLocalOmniRushConnection } from "./desktop-local-omnirush";
import { resolveOmniRushConnection } from "./omnirush-connection";
import { useReloadCoordinator } from "./reload-coordinator";
import { useShellConfig } from "./shell-config";
import { useShellShortcuts } from "./use-shell-shortcuts";
import { useEngineReload } from "./use-engine-reload";
import { useSessionGroupSync } from "./use-session-group-sync";
import { useUiStateStore } from "./ui-state-store";
import { useWorkspaceRouteState } from "./use-workspace-route-state";
import { CloudWorkspaceBootTakeover, useCloudWorkspaceStatus } from "./cloud-workspace-overlay";
import {
cloudWorkspaceStatusHasReadyContent,
mapCloudWorkspaceMainContentDecision,
shouldRefetchCloudWorkspaceOnReadyTransition,
} from "./cloud-workspace-status";
import { getReactQueryClient } from "@/react-app/infra/query-client";
import { useSessionControlActions } from "@/react-app/domains/session/control/session-control-actions";
import { openComposerConfigure, isLibraryAgent, type ComposerSettingsSection } from "@/react-app/domains/settings/library";
import {
globalExtensionsRoute,
legacySessionRoute,
mergeWorkspaceRouteSession,
automationsRoute,
dashboardRoute,
workspaceExtensionsRoute,
workspaceSessionRoute,
workspaceSettingsRoute,
workspaceTasksRoute,
} from "./workspace-routes";
import { TasksBoardPage } from "@/react-app/domains/workspace/tasks/tasks-board-page";
import { runningTaskCount, useWorkspaceTasks, workspaceTasksQueryKey } from "@/react-app/domains/workspace/tasks/workspace-tasks-query";
import type { HomeViewContext } from "@/react-app/domains/session/home/home-recent";
import { WorkspaceProvider } from "./workspace-provider";
import type { OpenTarget } from "@/react-app/domains/session/artifacts/open-target";
import { SettingsSurface } from "./settings-route";
import { writeStoredDefaultModel } from "@/react-app/kernel/model-config";
import {
ensureProviderListQuery,
getConnectedProviderItems,
refreshProviderListQueries,
useProviderListQuery,
} from "@/react-app/infra/provider-list-query";
/**
* Serialize an SDK error value into a string that parseSessionError can parse.
* Preserves the original shape (name, data, message) as JSON when possible,
* so the session surface can detect ProviderModelNotFoundError and offer
* recovery actions like "Change model".
*/
function serializeSDKError(error: unknown): string {
if (error instanceof Error) return error.message;
if (typeof error === "string") return error;
if (typeof error === "object" && error !== null) {
try {
return JSON.stringify(error);
} catch {
const msg = (error as Record<string, unknown>).message;
return typeof msg === "string" ? msg : String(error);
}
}
return String(error);
}
function describeTaskCreateError(error: unknown) {
const message = describeRouteError(error);
let serializedCode: unknown = null;
try {
const payload: unknown = JSON.parse(message);
serializedCode = typeof payload === "object" && payload !== null
? Reflect.get(payload, "code")
: null;
} catch {
// The normal error path is plain text, not a wire payload.
}
const directCode = typeof error === "object" && error !== null
? Reflect.get(error, "code")
: null;
const code = typeof directCode === "string" ? directCode : serializedCode;
if (code === "opencode_unconfigured") {
return "Choose a model for this workspace, then try again.";
}
const lower = message.toLowerCase();
if (
lower.includes("failed to fetch") ||
lower.includes("connection") ||
lower.includes("fetch failed") ||
lower.includes("econnrefused") ||
lower.includes("connection lost") ||
lower.includes("internal_error") ||
lower.includes("unexpected server error")
) {
return "omnirush.ai is unavailable for this workspace. Retry once it restarts, or restart omnirush.ai if the problem continues.";
}
return message;
}
function providerListModelEntitlementOptions(
providerList: ProviderListResponse | null | undefined,
): ModelEntitlementOption[] {
return getConnectedProviderItems(providerList).flatMap((provider) =>
Object.keys(provider.models ?? {}).map((modelID) => ({
providerID: provider.id,
modelID,
})),
);
}
function taskCreateUnavailableToastId(workspaceId: string) {
return `opencode-unavailable:${workspaceId}`;
}
function focusPromptSoon() {
if (typeof window === "undefined") return;
const focus = () => window.dispatchEvent(new Event("omnirush:focusPrompt"));
[0, 80, 240, 600].forEach((delay) => window.setTimeout(focus, delay));
}
const EVAL_UNAVAILABLE_PROVIDER_ID = "eval-unavailable-provider";
function nextEvalUnavailableModel(current: ModelRef | null | undefined) {
return {
providerID: EVAL_UNAVAILABLE_PROVIDER_ID,
modelID: current?.providerID === EVAL_UNAVAILABLE_PROVIDER_ID && current.modelID === "eval-unavailable-model-a"
? "eval-unavailable-model-b"
: "eval-unavailable-model-a",
} satisfies ModelRef;
}
function singlePickedDirectory(selection: string | string[] | null) {
return typeof selection === "string"
? selection
: Array.isArray(selection)
? selection[0] ?? null
: null;
}
function focusedWorkbenchPaneOwner() {
const workbench = useWorkbenchStore.getState();
const focused = workbench.focusedPane === "secondary" ? workbench.secondary : workbench.primary;
return focused
? JSON.stringify([workbench.focusedPane, focused.workspaceId, focused.sessionId])
: null;
}
export function SessionRoute() {
const navigate = useNavigate();
const location = useLocation();
const queryClient = useQueryClient();
const appsRouteActive = /^(?:\/apps|\/dashboard\/apps)(?:\/|$)/.test(location.pathname);
const automationsRouteRequested = /^\/automations(?:\/|$)/.test(location.pathname);
const dashboardRouteRequested = /^\/dashboard(?:\/|$)/.test(location.pathname);
const tasksRouteActive = /^\/workspace\/[^/]+\/tasks(?:\/|$)/.test(location.pathname);
// Work mode's home and Connectors page (domains/work); hidden unless the server turns Work on.
const workRouteRequested = /^\/work(?:\/|$)/.test(location.pathname);
const {
enabled: mcpAppsDashboardEnabled,
loading: dashboardAvailabilityLoading,
} = useDashboardDeploymentAvailability();
const dashboardRouteActive = mcpAppsDashboardEnabled && dashboardRouteRequested;
const dashboardWorkspaceRoute = dashboardRouteRequested
&& (dashboardAvailabilityLoading || mcpAppsDashboardEnabled);
const platform = usePlatform();
const toggleSidebar = useUiStateStore((state) => state.toggleSidebar);
const denAuth = useDenAuth();
const { config: shellConfig } = useShellConfig();
const appLocal = useLocal();
const automationDeploymentEnabled = useAutomationDeploymentEnabled();
// Desktop and Web share one Automations surface; the runtime only decides
// the placement of what each creates. Den's deployment flag stays the gate.
const automationsEnabled = automationDeploymentEnabled;
const automationsRouteActive = automationsEnabled && automationsRouteRequested;
const denSettings = readDenSettings();
const sessionDraftScope = resolveSessionDraftScope({
hasCloudCredential: Boolean(denSettings.authToken?.trim()),
verifiedIdentity: denAuth.verifiedIdentity,
});
const [automationsSupported, setAutomationsSupported] = useState(false);
const [automationsNeedAttention, setAutomationsNeedAttention] = useState(false);
useEffect(() => {
if (!automationsRouteRequested || automationsEnabled) return;
navigate("/", { replace: true });
}, [automationsEnabled, automationsRouteRequested, navigate]);
useEffect(() => {
if (!dashboardRouteRequested || dashboardAvailabilityLoading || mcpAppsDashboardEnabled) return;
navigate("/", { replace: true });
}, [dashboardAvailabilityLoading, dashboardRouteRequested, mcpAppsDashboardEnabled, navigate]);
useEffect(() => {
const authToken = denSettings.authToken?.trim();
const organizationId = denSettings.activeOrgId?.trim();
if (!automationsEnabled || !denAuth.isSignedIn || !authToken || !organizationId) {
setAutomationsSupported(false);
setAutomationsNeedAttention(false);
return;
}
let cancelled = false;
const client = createDenClient({ baseUrl: denSettings.baseUrl, token: authToken });
const refreshAutomationState = () => {
void client.listAutomations(organizationId, { limit: 100 })
.then((result) => {
if (cancelled) return;
setAutomationsSupported(true);
setAutomationsNeedAttention(result.items.some((item) => item.automation.state === "needs_attention"));
})
.catch(() => {
if (cancelled) return;
setAutomationsSupported(false);
setAutomationsNeedAttention(false);
});
};
refreshAutomationState();
const interval = window.setInterval(refreshAutomationState, 5 * 60_000);
window.addEventListener(automationsStateChangedEvent, refreshAutomationState);
return () => {
cancelled = true;
window.clearInterval(interval);
window.removeEventListener(automationsStateChangedEvent, refreshAutomationState);
};
}, [
automationsEnabled,
denAuth.isSignedIn,
denAuth.status,
denSettings.activeOrgId,
denSettings.authToken,
denSettings.baseUrl,
]);
const automationsNavigationAvailable = automationsEnabled && automationsSupported;
const reloadCoordinator = useReloadCoordinator();
const checkDesktopRestriction = useCheckDesktopRestriction();
const restrictionNotice = useRestrictionNotice();
const [activeOrganizationRole, setActiveOrganizationRole] = useState<DenOrgRole | null>(null);
const [omnirushServerHostInfoState, setOmniRushServerHostInfoState] = useState<OmniRushServerInfo | null>(null);
const [omnirushServerSettingsVersion, setOmniRushServerSettingsVersion] = useState(0);
const [developerMode, setDeveloperMode] = useState(() => {
if (typeof window === "undefined") return false;
return window.localStorage.getItem("omnirush.developerMode") === "1";
});
const {
navigateToWorkspaceSession,
routeWorkspaceId,
selectedSessionId,
loading,
effectiveLoading,
client,
baseUrl,
token,
workspaces,
setWorkspaces,
workspacesRef,
workspaceOrderIds,
setWorkspaceOrderIds,
workspaceOrderIdsRef,
sessionsByWorkspaceId,
setSessionsByWorkspaceId,
sessionsByWorkspaceIdRef,
errorsByWorkspaceId,
setErrorsByWorkspaceId,
sessionListErrorsByWorkspaceId,
workspaceConnectionOverrides,
routeError,
setRouteError,
legacySelectedWorkspaceId,
setLegacySelectedWorkspaceId,
retryingWorkspaceIds,
setRetryingWorkspaceIds,
startupRetryTimerRef,
selectedWorkspaceId,
selectedWorkspace,
selectedWorkspaceRoot,
selectedWorkspaceEndpoint,
selectedWorkspaceServerToken,
opencodeBaseUrl,
opencodeClient,
selectedWorkspaceIsLoading,
selectedWorkspaceError,
routeNotFoundMessage,
endpointForWorkspace,
refreshRouteState,
reloadWorkspaceSessions,
retryWorkspaceSessions,
rememberPendingCreatedSession,
handleRuntimeSessionCreated,
handleRuntimeSessionUpdated,
handleRuntimeSessionDeleted,
forgetDeletedSession,
forgetMissingSession,
handleRemoteWorkspaceConnectionSaved,
runRemoteWorkspaceConnectionCheck,
} = useWorkspaceRouteState({
developerMode,
workspaceRoute: workRouteRequested ? "work" : tasksRouteActive ? "tasks" : appsRouteActive ? "apps" : automationsRouteActive ? "automations" : dashboardWorkspaceRoute ? "dashboard" : "session",
onServerSettingsChanged: () => setOmniRushServerSettingsVersion((value) => value + 1),
onHostInfo: setOmniRushServerHostInfoState,
});
// Model picks here are the open project's own (project-model-prefs.ts); Settings keeps the app default.
const local = useProjectModelLocal(appLocal, selectedWorkspaceId);
// Work mode: Code (today's app) or Work (business chats in the app-managed Work workspace). The mode
// follows the route; the last one picked is remembered and reopened at start.
const workState = useWorkState(client ?? null);
const workEnabled = workState.data?.enabled === true;
const storedAppMode = useWorkModeStore((state) => state.mode);
const workWorkspace = workspaces.find((workspace) => workspace.preset === WORK_PRESET && workspace.workspaceType !== "remote") ?? null;
const workChatActive = workEnabled && Boolean(selectedWorkspace && selectedWorkspace.preset === WORK_PRESET) && !workRouteRequested;
const workRouteActive = workEnabled && workRouteRequested;
const appMode: AppMode = workRouteActive || workChatActive ? "work" : "code";
const appModeRestored = useRef(false);
useEffect(() => {
if (workState.isPending) return;
if (workRouteRequested && !workEnabled) {
navigate("/session", { replace: true });
return;
}
// Work off: its workspace is no project; leave it for a Code one (never open it with the IDE).
if (!workEnabled && selectedWorkspace?.preset === WORK_PRESET) {
const codeWorkspace = workspaces.find((workspace) => workspace.preset !== WORK_PRESET && !workspace.task);
if (codeWorkspace) navigateToWorkspaceSession(codeWorkspace.id, readLastSessionFor(codeWorkspace.id));
else navigate("/session", { replace: true });
return;
}
if (appModeRestored.current || !workEnabled) return;
appModeRestored.current = true;
if (storedAppMode === "work" && appMode === "code" && !routeWorkspaceId) navigate(WORK_HOME_ROUTE, { replace: true });
}, [appMode, navigate, navigateToWorkspaceSession, routeWorkspaceId, selectedWorkspace?.preset, storedAppMode, workEnabled, workRouteRequested, workState.isPending, workspaces]);
// The Work workspace is made on the first visit to Work (the server picks its folder).
const workWorkspaceRequested = useRef(false);
useEffect(() => {
if (!workRouteActive || workWorkspace || !client || workWorkspaceRequested.current) return;
workWorkspaceRequested.current = true;
void client.ensureWorkWorkspace()
.then(() => refreshRouteState())
.catch((error: unknown) => {
workWorkspaceRequested.current = false;
toast.error(error instanceof Error ? error.message : "Work could not be set up.");
});
}, [client, refreshRouteState, workRouteActive, workWorkspace]);
const switchAppMode = useCallback((mode: AppMode) => {
useWorkModeStore.getState().setMode(mode);
if (mode === "work") {
navigate(WORK_HOME_ROUTE);
return;
}
const codeWorkspace = workspaces.find((workspace) => workspace.preset !== WORK_PRESET && !workspace.task);
if (codeWorkspace) navigateToWorkspaceSession(codeWorkspace.id, readLastSessionFor(codeWorkspace.id));
else navigate("/session");
}, [navigate, navigateToWorkspaceSession, workspaces]);
useEffect(() => {
if (!workEnabled) return;
const mac = typeof navigator !== "undefined" && /Mac/i.test(navigator.platform);
const handler = (event: KeyboardEvent) => {
if (!isWorkModeShortcut(event, mac)) return;
event.preventDefault();
switchAppMode(appMode === "work" ? "code" : "work");
};
window.addEventListener("keydown", handler);
return () => window.removeEventListener("keydown", handler);
}, [appMode, switchAppMode, workEnabled]);
// "Send feedback" from a menu that does not know the open session (Help menu, sidebar).
useEffect(() => {
setFeedbackCurrentSession(selectedSessionId ?? null);
return () => setFeedbackCurrentSession(null);
}, [selectedSessionId]);
const routeNavigationRef = useRef({ locationKey: location.key, generation: 0 });
if (routeNavigationRef.current.locationKey !== location.key) {
routeNavigationRef.current = {
locationKey: location.key,
generation: routeNavigationRef.current.generation + 1,
};
}
const selectedConversationRef = useRef({
workspaceId: selectedWorkspaceId,
sessionId: selectedSessionId,
draftScope: sessionDraftScope,
location: `${location.pathname}${location.search}`,
locationKey: location.key,
navigationGeneration: routeNavigationRef.current.generation,
});
selectedConversationRef.current = {
workspaceId: selectedWorkspaceId,
sessionId: selectedSessionId,
draftScope: sessionDraftScope,
location: `${location.pathname}${location.search}`,
locationKey: location.key,
navigationGeneration: routeNavigationRef.current.generation,
};
// Archiving is the app's own flag on 2.x (the server keeps it): always available.
const archiveDisabledReason: string | undefined = undefined;
// The dashboard is user-scoped while MCP servers are workspace-scoped: the
// selected workspace's runtime is primary, and every other available one is
// a per-tile fallback so tiles keep working when the selected workspace does
// not configure their server.
const dashboardEndpoints = useMemo(() => {
if (!dashboardRouteActive) return [];
const endpoints: ResolvedWorkspaceEndpoint[] = [];
if (selectedWorkspaceEndpoint) endpoints.push(selectedWorkspaceEndpoint);
for (const workspace of workspaces) {
const endpoint = endpointForWorkspace(workspace);
if (endpoint && !endpoints.some((existing) => existing.workspaceId === endpoint.workspaceId)) {
endpoints.push(endpoint);
}
}
return endpoints;
}, [dashboardRouteActive, endpointForWorkspace, selectedWorkspaceEndpoint, workspaces]);
const dashboardEndpoint = dashboardEndpoints[0] ?? null;
const dashboardFallbackEndpoints = useMemo(
() => dashboardEndpoints.slice(1).map((endpoint) => ({
client: endpoint.client,
workspaceId: endpoint.workspaceId,
})),
[dashboardEndpoints],
);
const cloudWorkspace = useCloudWorkspaceStatus();
const bootOverlayVisible = useBootOverlayVisible();
const previousCloudWorkspaceStatusRef = useRef<typeof cloudWorkspace.viewModel.variant | null>(null);
useEffect(() => {
const previousStatus = previousCloudWorkspaceStatusRef.current;
previousCloudWorkspaceStatusRef.current = cloudWorkspace.viewModel.variant;
if (!shouldRefetchCloudWorkspaceOnReadyTransition({
previousStatus,
nextStatus: cloudWorkspace.viewModel.variant,
gatewayMode: cloudWorkspace.gatewayMode && cloudWorkspace.visible,
})) return;
void refreshRouteState({ supersede: true });
}, [cloudWorkspace.gatewayMode, cloudWorkspace.viewModel.variant, cloudWorkspace.visible, refreshRouteState]);
const cloudMcpProviderModel = useMemo(() => local.prefs.defaultModel
? {
provider: local.prefs.defaultModel.providerID,
model: local.prefs.defaultModel.modelID,
}
: undefined, [local.prefs.defaultModel?.modelID, local.prefs.defaultModel?.providerID]);
const sessionMcpMaintenance = useSessionMcpMaintenance({
enabled: false,
cloudSignedIn: denAuth.isSignedIn,
client: selectedWorkspaceEndpoint?.client ?? null,
workspaceId: selectedWorkspaceEndpoint?.workspaceId ?? null,
opencodeClient,
directory: selectedWorkspaceRoot,
engineReloadBusy: reloadCoordinator.reloadBusy,
providerModel: cloudMcpProviderModel,
});
const {
state: cloudMcpSubmissionState,
submit: submitWithCloudMcpReadiness,
clearFailure: clearCloudMcpSubmissionFailure,
} = useCloudMcpSubmitReadiness({
enabled: false,
cloudAuthStatus: denAuth.status,
client: selectedWorkspaceEndpoint?.client ?? null,
workspaceId: selectedWorkspaceEndpoint?.workspaceId ?? null,
providerModel: cloudMcpProviderModel,
});
// Agent selection is persisted in local prefs (like the model variant) so
// it survives reloads instead of silently falling back to "build" (#2101).
const selectedAgent = local.prefs.selectedAgent;
const setSelectedAgent = useCallback(
(agent: string | null) => {
local.setPrefs((previous) => ({ ...previous, selectedAgent: agent }));
},
[local.setPrefs],
);
// One-way latch for "a refreshRouteState is currently running"; prevents
// overlapping route refreshes from queueing up when the user clicks fast.
const [createWorkspaceOpen, setCreateWorkspaceOpen] = useState(false);
const [createWorkspaceBusy, setCreateWorkspaceBusy] = useState(false);
const [createWorkspaceError, setCreateWorkspaceError] = useState<string | null>(null);
const [createWorkspaceRemoteBusy, setCreateWorkspaceRemoteBusy] = useState(false);
const [createWorkspaceRemoteError, setCreateWorkspaceRemoteError] = useState<string | null>(null);
const [renameWorkspaceId, setRenameWorkspaceId] = useState<string | null>(null);
const [renameWorkspaceTitle, setRenameWorkspaceTitle] = useState("");
const [renameWorkspaceBusy, setRenameWorkspaceBusy] = useState(false);
const [paletteAccessibleTargets, setPaletteAccessibleTargets] = useState<OpenTarget[]>([]);
const [providers, setProviders] = useState<ProviderListItem[]>([]);
const [providerDefaults, setProviderDefaults] = useState<Record<string, string>>({});
const [providerConnectedIds, setProviderConnectedIds] = useState<string[]>([]);
const [disabledProviderIds, setDisabledProviderIds] = useState<string[]>([]);
// Bump to re-filter provider list when den session changes (sign-in/out)
const [denSessionVersion, setDenSessionVersion] = useState(0);
useEffect(() => {
const handler = () => setDenSessionVersion((v) => v + 1);
window.addEventListener(denSessionUpdatedEvent, handler);
window.addEventListener(denSettingsChangedEvent, handler);
return () => {
window.removeEventListener(denSessionUpdatedEvent, handler);
window.removeEventListener(denSettingsChangedEvent, handler);
};
}, []);
// Provider IDs that were just added — used to highlight them as
useEffect(() => {
setPaletteAccessibleTargets([]);
}, [selectedSessionId, selectedWorkspaceId]);
// Provider catalog cache. Used to compute the reasoning/thinking variant
// options for whichever model is currently selected so the composer's
// behavior pill actually shows its options (bug: was empty before).
const omnirushServerSettings = useMemo(
() => readOmniRushServerSettings(),
[omnirushServerSettingsVersion],
);
const activeReloadBlockingSessions = useMemo(
() =>
Object.values(sessionsByWorkspaceId)
.flat()
.flatMap((session) => {
if (!isActiveSessionStatus(getSessionStatus(session))) return [];
const id = String(session?.id ?? "");
if (!id) return [];
return [{
id,
title:
String(session?.title ?? session?.slug ?? session?.id ?? "").trim() ||
t("session.untitled"),
}];
}),
[sessionsByWorkspaceId],
);
const selectedInteractionSessionIds = useMemo(() => {
const selected = selectedSessionId?.trim();
if (!selected) return [];
const sessions = sessionsByWorkspaceId[selectedWorkspaceId] ?? [];
return [selected, ...getSessionDescendantIds(sessions, selected)];
}, [selectedSessionId, selectedWorkspaceId, sessionsByWorkspaceId]);
const activeSelectedWorkspaceSessionIds = useMemo(
() => Array.from(new Set([
...selectedInteractionSessionIds,
...(sessionsByWorkspaceId[selectedWorkspaceId] ?? []).flatMap((session) => {
if (!isActiveSessionStatus(getSessionStatus(session))) return [];
const id = String(session?.id ?? "").trim();
return id ? [id] : [];
}),
])),
[selectedInteractionSessionIds, selectedWorkspaceId, sessionsByWorkspaceId],
);
const remoteAccessRestart = useRemoteAccessRestart({
isEnabled: () => omnirushServerSettings.remoteAccessEnabled === true,
onHostInfo: setOmniRushServerHostInfoState,
onSettingsChanged: () => setOmniRushServerSettingsVersion((value) => value + 1),
});
const { engineReloadVersion, routeEngineInfo, reloadWorkspaceEngineFromUi } = useEngineReload({
client,
workspaceId: selectedWorkspaceId,
workspace: selectedWorkspace,
endpointForWorkspace,
activeReloadBlockingSessions,
onError: setRouteError,
refreshRouteState,
});
const environmentRuntimeKey = useMemo(
() => buildOmniRushEnvRuntimeKey({
baseUrl: client?.baseUrl ?? null,
pid: omnirushServerHostInfoState?.pid ?? null,
port: omnirushServerHostInfoState?.port ?? null,
}),
[client?.baseUrl, omnirushServerHostInfoState?.pid, omnirushServerHostInfoState?.port],
);
const handleApplyEnvironmentChanges = useCallback(async () => {
if (!isDesktopRuntime()) {
throw new Error(t("settings.environment.apply_unavailable"));
}
if (activeReloadBlockingSessions.length > 0) {
throw new Error(t("settings.environment.apply_blocked_active_tasks"));
}
if (!selectedWorkspaceRoot) {
throw new Error(t("settings.environment.apply_no_local_workspace"));
}
const reloaded = await reloadWorkspaceEngineFromUi();
if (!reloaded) {
throw new Error(t("app.error_connect_first"));
}
}, [activeReloadBlockingSessions.length, reloadWorkspaceEngineFromUi, selectedWorkspaceRoot]);
const shareWorkspaceState = useShareWorkspaceState({
workspaces,
omnirushServerHostInfo: omnirushServerHostInfoState,
omnirushServerSettings,
engineInfo: routeEngineInfo,
exportWorkspaceBusy: false,
openLink: (url) => platform.openLink(url),
workspaceLabel,
});
const remoteWorkspaceConnectionEditor = useRemoteWorkspaceConnectionEditor({
workspaces,
client,
onSaved: handleRemoteWorkspaceConnectionSaved,
});
const workspaceSessionGroups = useMemo(
() => toSessionGroups(
workspaces,
sessionsByWorkspaceId,
errorsByWorkspaceId,
new Set(retryingWorkspaceIds),
sessionListErrorsByWorkspaceId,
),
[errorsByWorkspaceId, retryingWorkspaceIds, sessionListErrorsByWorkspaceId, sessionsByWorkspaceId, workspaces],
);
useSessionGroupSync({ workspaces, endpointForWorkspace });
// A parallel task's own workspace is listed on its repository's board, not in the sidebar (unless it is open).
const sidebarWorkspaceSessionGroups = useMemo(
() => workspaceSessionGroups
.filter((group) => !group.workspace.task || group.workspace.id === selectedWorkspaceId)
// Work lists only the Work workspace's chats; Code (and the app while Work is off) never lists it.
.filter((group) => shownInMode(group.workspace, workEnabled, appMode)),
[appMode, selectedWorkspaceId, workEnabled, workspaceSessionGroups],
);
const tasksBoardWorkspaceId = selectedWorkspace?.task && workspaces.some((workspace) => workspace.id === selectedWorkspace.task?.parentWorkspaceId)
? selectedWorkspace.task.parentWorkspaceId
: selectedWorkspaceId;
const tasksAvailable = Boolean(selectedWorkspace && selectedWorkspace.workspaceType !== "remote" && tasksBoardWorkspaceId);
const workspaceTasksQuery = useWorkspaceTasks(client, tasksBoardWorkspaceId, tasksAvailable);
const tasksRunningCount = runningTaskCount(workspaceTasksQuery.data);
const selectedWorkspaceGroupState = sessionManagementStore((state) => (
selectedWorkspaceId ? state.groupsByWorkspace[selectedWorkspaceId] : undefined
));
const assignSessionToGroup = sessionManagementStore((state) => state.assignGroup);
const currentSessionPinned = sessionManagementStore((state) => (
selectedSessionId ? state.pinnedIds.includes(selectedSessionId) : false
));
const seedWorkspaceActivitySessions = useSessionActivityStore((state) => state.seedWorkspaceSessions);
const sessionActivityByWorkspaceId = useSessionActivityStore((state) => state.statusesByWorkspaceId);
useEffect(() => {
for (const group of workspaceSessionGroups) {
seedWorkspaceActivitySessions(group.workspace.id, group.sessions);
const serverId = workspaceServerId(group.workspace);
if (serverId && serverId !== group.workspace.id) {
seedWorkspaceActivitySessions(serverId, group.sessions);
}
}
}, [seedWorkspaceActivitySessions, workspaceSessionGroups]);
const sidebarSessionStatusById = useMemo(() => {
const next: Record<string, string> = {};
for (const group of workspaceSessionGroups) {
const serverId = workspaceServerId(group.workspace);
const workspaceStatuses = {
...(sessionActivityByWorkspaceId[group.workspace.id] ?? {}),
...(serverId ? sessionActivityByWorkspaceId[serverId] ?? {} : {}),
};
for (const session of group.sessions) {
const status = workspaceStatuses[session.id];
if (status) next[session.id] = status;
}
}
return next;
}, [sessionActivityByWorkspaceId, workspaceSessionGroups]);
const sidebarActiveWorkspaceId = useMemo(() => {
const sessionId = selectedSessionId?.trim() ?? "";
if (sessionId) {
const owner = workspaceSessionGroups.find((group) =>
group.sessions.some((session) => session?.id === sessionId),
);
if (owner?.workspace.id) return owner.workspace.id;
}
return selectedWorkspaceId;
}, [selectedSessionId, selectedWorkspaceId, workspaceSessionGroups]);
const workspaceConnectionStateById = useMemo(() => {
const next: Record<string, WorkspaceConnectionState> = { ...workspaceConnectionOverrides };
for (const workspace of workspaces) {
if (workspace.workspaceType !== "remote") continue;
const error = errorsByWorkspaceId[workspace.id]?.trim();
if (!error || next[workspace.id]?.status === "connecting") continue;
next[workspace.id] ??= {
status: "error",
message: getWorkspaceTaskLoadErrorDisplay(workspace, error).message || error,
checkedAt: null,
};
}
return next;
}, [errorsByWorkspaceId, workspaceConnectionOverrides, workspaces]);
const mcpConnectedCount = useMcpConnectedCount(opencodeClient, selectedWorkspaceRoot);
const providerListQuery = useProviderListQuery({
client: opencodeClient,
baseUrl: opencodeBaseUrl,
directory: selectedWorkspaceRoot || undefined,
});
const { providerCatalog, modelVariantLabel, modelBehaviorOptions, modelVariantValue } =
useModelBehavior({
providerList: providerListQuery.data,
defaultModel: local.prefs.defaultModel,
modelVariant: local.prefs.modelVariant ?? null,
});
const {
store: sessionProviderAuthStore,
snapshot: sessionProviderAuthSnapshot,
cloudProviderSyncReady,
cloudProviderList,
refreshCloudProviderSync,
} = useSessionProviderAuth({
opencodeClient,
opencodeBaseUrl,
providers,
providerDefaults,
providerConnectedIds,
disabledProviderIds,
selectedWorkspace,
selectedWorkspaceEndpoint,
selectedWorkspaceRoot,
selectedWorkspaceId,
localServerHostToken: omnirushServerHostInfoState?.hostToken?.trim() ?? "",
setProviders,
setProviderDefaults,
setProviderConnectedIds,
setDisabledProviderIds,
});
const organizationAssignedModelOptions = useMemo(
() => assignedModelOptions(sessionProviderAuthSnapshot.cloudOrgProviders),
[sessionProviderAuthSnapshot.cloudOrgProviders],
);
useEffect(() => {
if (!denAuth.isSignedIn) {
setActiveOrganizationRole(null);
return;
}
const settings = readDenSettings();
const tokenValue = settings.authToken?.trim() ?? "";
const activeOrgId = settings.activeOrgId?.trim() ?? "";
const activeOrgSlug = settings.activeOrgSlug?.trim() ?? "";
if (!tokenValue || (!activeOrgId && !activeOrgSlug)) {
setActiveOrganizationRole(null);
return;
}
let cancelled = false;
void createDenClient({ baseUrl: settings.baseUrl, token: tokenValue })
.listOrgs()
.then((response) => {
if (cancelled) return;
const active = response.orgs.find((org) =>
org.id === activeOrgId || org.slug === activeOrgSlug,
);
setActiveOrganizationRole(active?.role ?? null);
})
.catch(() => {
if (!cancelled) setActiveOrganizationRole(null);
});
return () => {
cancelled = true;
};
}, [denAuth.isSignedIn, denAuth.status, denSessionVersion]);
const handleModelPickerOpen = useCallback(() => {
void refreshCloudProviderSync("model_picker_open");
}, [refreshCloudProviderSync]);
const omniRushModelsEntitled = useMemo(() => {
if (!denAuth.isSignedIn) return false;
const fromOrg = sessionProviderAuthSnapshot.cloudOrgProviders.some(
(provider) =>
[provider.providerId, provider.source].some(
(value) => value?.trim().toLowerCase() === "omnirush",
),
);
const fromImport = Object.values(sessionProviderAuthSnapshot.importedCloudProviders ?? {}).some(
(provider) =>
[provider.providerId, provider.source, provider.sourceProviderId].some(
(value) => value?.trim().toLowerCase() === "omnirush",
),
);
return fromOrg || fromImport;
}, [
denAuth.isSignedIn,
sessionProviderAuthSnapshot.cloudOrgProviders,
sessionProviderAuthSnapshot.importedCloudProviders,
]);
const refreshOrganizationModelAccess = useCallback(async () => {
await refreshCloudProviderSync("manual");
}, [refreshCloudProviderSync]);
useEffect(() => {
if (!cloudProviderSyncReady || !cloudProviderList) return;
clearCloudMcpSubmissionFailure();
}, [clearCloudMcpSubmissionFailure, cloudProviderList, cloudProviderSyncReady]);
const organizationModelsSettingsUrl = useMemo(() => {
if (!isDenOrgAdminRole(activeOrganizationRole)) {
return undefined;
}
return new URL("/dashboard/custom-llm-providers", readDenSettings().baseUrl).toString();
}, [activeOrganizationRole, denSessionVersion]);
const restrictToCloudProviders = checkDesktopRestriction({ restriction: "allowCustomProviders" });
const entitledModelOptions = useMemo(() => {
const runtimeOptions = providerListModelEntitlementOptions(
cloudProviderList ?? providerListQuery.data,
);
return filterEntitledModelOptions(
runtimeOptions.length > 0 ? runtimeOptions : organizationAssignedModelOptions,
{
restrictToCloud: restrictToCloudProviders,
checkRestriction: checkDesktopRestriction,
},
);
}, [
checkDesktopRestriction,
cloudProviderList,
organizationAssignedModelOptions,
providerListQuery.data,
restrictToCloudProviders,
]);
const omniRushModelsAvailable = hasOmniRushModelsAvailable({
providerConnectedIds,
providers,
});
const omniRushModelsSyncing = shouldShowOmniRushModelsSyncing({
entitled: omniRushModelsEntitled,
available: omniRushModelsAvailable,
workspaceReady: Boolean(selectedWorkspaceId && opencodeClient),
reloadPending: sessionProviderAuthSnapshot.cloudProviderServerSync?.reloadPending === true,
});
const organizationModelsEmpty = isOrganizationModelsEmpty({
workspaceReady: Boolean(selectedWorkspaceId && opencodeClient),
loading,
restrictToCloud: restrictToCloudProviders,
cloudProviderSyncReady,
entitledModelCount: entitledModelOptions.length,
});
// The open project's mode (sandbox or not) and the models it allows (model-modes.ts).
const modelModes = useProjectModelModes(selectedWorkspaceEndpoint?.client ?? null, selectedWorkspaceEndpoint?.workspaceId ?? null, selectedSessionId || null);
const modelModesRef = useRef(modelModes);
modelModesRef.current = modelModes;
useClaudeModelSync(selectedWorkspaceEndpoint?.client ?? null, selectedWorkspaceEndpoint?.workspaceId ?? null);
// The default as this project may use it: one its mode does not allow moves to the allowed default.
const projectDefaultModel = modelModes.fallback(local.prefs.defaultModel ?? null) ?? local.prefs.defaultModel ?? null;
/**
* The model a send in the open project goes out on. A chat's model is fixed
* once it sent a prompt: if its project's mode no longer allows it (the
* sandbox turned on or off since), nothing is sent and the person is told to
* start a new chat. Only a new chat moves to the allowed default, with a note.
*/
const modeSendModel = (model: ModelRef | null | undefined, sessionId: string | null): ModelRef | null => {
const rules = modelModesRef.current;
if (!model) return null;
if (sessionId && chatStarted(sessionId)) {
if (!rules.allows(model)) throw new Error(rules.chatNote(model));
return model;
}
if (rules.allowsNew(model)) return model;
const next = rules.fallback(model);
if (!next) return model;
toast(rules.note(model, next), { id: `model-mode:${sessionId ?? "new"}` });
if (sessionId) useSessionModelStore.getState().setModel(sessionId, next, null);
return next;
};
const modelPicker = useModelPicker({
client: opencodeClient,
baseUrl: opencodeBaseUrl,
workspaceRoot: selectedWorkspaceRoot,
onOpen: handleModelPickerOpen,
fallbackOptions: organizationAssignedModelOptions,
cloudProvidersEnabled: denAuth.isSignedIn,
});
// Which session the open model picker targets. Selecting a model while a
// session is targeted remembers it for that conversation only; null means
// the picker edits the global default (e.g. opened from the new-providers
// toast). Composer "All models" carries the session id on the open event.
const [modelPickerSessionId, setModelPickerSessionId] = useState<string | null>(null);
useEffect(() => {
const handler = (event: Event) => {
const detail = (event as CustomEvent<{ sessionId?: string }>).detail;
setModelPickerSessionId(typeof detail?.sessionId === "string" ? detail.sessionId : null);
};
window.addEventListener(openModelPickerEvent, handler);
return () => window.removeEventListener(openModelPickerEvent, handler);
}, []);
const entitledOrgDefaultModel = useMemo(() => {
const runtimeOptions = providerListModelEntitlementOptions(
cloudProviderList ?? providerListQuery.data,
);
return resolveEntitledOrgDefaultModel(
runtimeOptions.length > 0 ? runtimeOptions : organizationAssignedModelOptions,
{
currentDefault: local.prefs.defaultModel,
restrictToCloud: restrictToCloudProviders,
checkRestriction: checkDesktopRestriction,
},
);
}, [
checkDesktopRestriction,
cloudProviderList,
local.prefs.defaultModel,
organizationAssignedModelOptions,
providerListQuery.data,
restrictToCloudProviders,
]);
useEffect(() => {
if (entitledOrgDefaultModel) writeStoredDefaultModel(entitledOrgDefaultModel);
}, [entitledOrgDefaultModel]);
// Availability is resolved per effective model identity: the New Task
// composer validates the global default while each conversation validates
// its OWN remembered provider/model against the current workspace's
// catalogs. The provider-list query is keyed by server + workspace
// directory, so a workspace switch supersedes the old catalog (the new key
// reads as unsettled → pending) instead of judging the new workspace with
// stale data.
//
// Catalog denials are additionally confirmation-gated: Settings visits and
// engine reload churn can settle a momentarily incomplete catalog, and a
// denial younger than the confirmation window renders as pending instead of
// flashing "Model no longer available" during the transition. The recheck
// tick re-evaluates tracked denials so a genuine one still surfaces once it
// matures, even without further catalog changes.
const modelAvailabilityGate = useMemo(() => createUnavailableConfirmationGate(), []);
const [availabilityRecheckTick, bumpAvailabilityRecheck] = useReducer(
(value: number) => value + 1,
0,
);
const resolveModelAvailability = useCallback((model: ModelRef | null): ModelAvailability =>
modelAvailabilityGate.confirm(model, computeModelAvailability(model, {
workspaceReady: Boolean(selectedWorkspaceId && opencodeClient),
loading,
signedIn: denAuth.isSignedIn,
cloudProviderSyncReady,
omniRushModelsSyncing,
restrictToCloud: restrictToCloudProviders,
checkRestriction: checkDesktopRestriction,
cloudProviderList,
providerList: providerListQuery.data,
})), [
// The tick only forces re-evaluation of denials tracked by the gate.
availabilityRecheckTick,
checkDesktopRestriction,
cloudProviderList,
cloudProviderSyncReady,
denAuth.isSignedIn,
loading,
modelAvailabilityGate,
opencodeClient,
omniRushModelsSyncing,
providerListQuery.data,
restrictToCloudProviders,
selectedWorkspaceId,
]);
useEffect(() => {
const delay = modelAvailabilityGate.nextRecheckDelay();
if (delay === null) return;
const timer = window.setTimeout(() => bumpAvailabilityRecheck(), delay + 16);
return () => window.clearTimeout(timer);
}, [modelAvailabilityGate, resolveModelAvailability]);
const selectedModelUnavailable =
resolveModelAvailability(local.prefs.defaultModel ?? null).status === "unavailable";
// The composer the user is looking at: the selected conversation's
// remembered model when it has one, otherwise the global default.
const selectedSessionModelSelection = useSessionModelStore((state) =>
(selectedSessionId ? state.bySessionId[selectedSessionId] ?? null : null),
);
const activeComposerModel = selectedSessionModelSelection?.model ?? projectDefaultModel;
const activeComposerAvailability = resolveModelAvailability(activeComposerModel);
const activeComposerTargetsSession = Boolean(selectedSessionModelSelection && selectedSessionId);
const selectedModelUnavailableKey = activeComposerAvailability.status === "unavailable" && activeComposerModel
? `${activeComposerTargetsSession ? selectedSessionId : "default"}:${activeComposerModel.providerID}:${activeComposerModel.modelID}`
: null;
const autoOpenedUnavailableModelRef = useRef<string | null>(null);
// A conversation whose remembered model can no longer be used (its provider is
// locked or blocked, or the model left the catalog: e.g. a chat from before an
// update) moves to the working default with a notice, instead of a disabled
// composer and a picker to sort out.
// Re-renders when the server's lock answer arrives (providerLockAnswered below).
useProviderLock();
const sessionFallbackModel = activeComposerTargetsSession
? sessionModelFallback({
sessionModel: selectedSessionModelSelection?.model,
sessionAvailability: activeComposerAvailability,
defaultModel: local.prefs.defaultModel,
defaultAvailability: resolveModelAvailability(local.prefs.defaultModel ?? null),
lockAnswered: providerLockAnswered(),
})
: null;
const sessionFallbackKey = sessionFallbackModel && selectedSessionId && selectedSessionModelSelection
? `${selectedSessionId}:${selectedSessionModelSelection.model.providerID}:${selectedSessionModelSelection.model.modelID}`
: null;
useEffect(() => {
if (!sessionFallbackKey || !sessionFallbackModel || !selectedSessionId) return;
const previous = getSessionModelSelection(selectedSessionId)?.model;
if (!previous) return;
useSessionModelStore.getState().setModel(selectedSessionId, sessionFallbackModel, local.prefs.modelVariant ?? null);
const providerItem = (id: string) => providers.find((item) => item.id === id);
const fallbackProvider = providerItem(sessionFallbackModel.providerID);
const modelName = resolveModelDisplayName(
sessionFallbackModel.modelID,
fallbackProvider?.models?.[sessionFallbackModel.modelID]?.name ?? null,
);
const providerName = providerItem(previous.providerID)?.name?.trim() || previous.providerID;
toast(t("models.switched_unavailable", { model: modelName, provider: providerName }), {
id: `session-model-switched:${selectedSessionId}`,
});
// Keyed on the session and the model it remembered: one switch and one notice each.
}, [sessionFallbackKey]);
useEffect(() => {
// The conversation is about to move to the default model (above): no picker for it.
if (sessionFallbackKey) return;
if (!selectedModelUnavailableKey) {
// The active composer's model is fine (or pending). If the picker was
// auto-opened for a previously broken composer — e.g. the New Task
// default — do not let that recovery modal follow the user into a
// conversation whose own model is valid.
if (autoOpenedUnavailableModelRef.current) {
modelPicker.setOpen(false);
}
autoOpenedUnavailableModelRef.current = null;
return;
}
if (!shouldAutoOpenUnavailableModelPicker({
selectedModelUnavailableKey,
signedIn: denAuth.isSignedIn,
cloudProviderSyncReady,
// Silent default repair only applies when the broken selection IS the
// default. A conversation's own unavailable model moves to the default
// with a notice when that is definite (sessionModelFallback: a blocked
// provider, a retired OmniRush model); otherwise the picker surfaces
// for that conversation.
entitledOrgDefaultModel: activeComposerTargetsSession ? false : Boolean(entitledOrgDefaultModel),
organizationModelsEmpty,
autoOpenedUnavailableModelKey: autoOpenedUnavailableModelRef.current,
})) return;
if (!activeComposerTargetsSession && entitledOrgDefaultModel) {
writeStoredDefaultModel(entitledOrgDefaultModel);
return;
}
autoOpenedUnavailableModelRef.current = selectedModelUnavailableKey;
setModelPickerSessionId(activeComposerTargetsSession ? selectedSessionId : null);
modelPicker.setQuery("");
modelPicker.setRecentProviderIds(new Set());
modelPicker.setCompactOpen(false);
modelPicker.setOpen(true);
}, [activeComposerTargetsSession, cloudProviderSyncReady, denAuth.isSignedIn, entitledOrgDefaultModel, modelPicker.setCompactOpen, modelPicker.setOpen, modelPicker.setQuery, modelPicker.setRecentProviderIds, organizationModelsEmpty, selectedModelUnavailableKey, selectedSessionId, sessionFallbackKey]);
// Optimistic model selection: a remembered model is treated as valid until
// the availability gate CONFIRMS it absent (selectedModelUnavailable).
// A merely-pending verdict (cloud sync settling, catalog reloading) never
// blocks task creation or paints loading chrome — if the optimism turns out
// wrong, the send-time re-check and the composer's model-unavailable pill
// surface it where the person can act on it.
const hasUsableModel = Boolean(
local.prefs.defaultModel &&
!selectedModelUnavailable,
);
const canCreateTask = Boolean(
opencodeClient &&
selectedWorkspaceId &&
!loading &&
!selectedWorkspaceError &&
!selectedModelUnavailable,
);
const {
activePermission,
permissionReplyBusy,
respondPermission,
activeQuestion,
questionReplyBusy,
respondQuestion,
todos,
} = useSessionInteractions({
client: opencodeClient,
// Match ReactSessionRuntime and SessionSurface: remote route IDs can carry
// a client-only prefix, while interaction caches use the server workspace.
workspaceId: selectedWorkspaceEndpoint?.workspaceId ?? selectedWorkspaceId,
sessionId: selectedSessionId,
interactionSessionIds: selectedInteractionSessionIds,
workspaceRoot: selectedWorkspaceRoot,
});
const activePermissionSourceTitle = useMemo(() => {
if (!activePermission || activePermission.sessionID === selectedSessionId) return null;
const source = (sessionsByWorkspaceId[selectedWorkspaceId] ?? []).find(
(session) => session.id === activePermission.sessionID,
);
return String(source?.title ?? source?.slug ?? "").trim() || t("session.subagent_task");
}, [activePermission, selectedSessionId, selectedWorkspaceId, sessionsByWorkspaceId]);
const modelUnavailableMessage = organizationModelsEmpty
? t("models.organization_models_empty")
: selectedModelUnavailable
? t("models.model_unavailable_short")
: null;
useEffect(() => {
if (!opencodeClient) {
setProviders([]);
setProviderDefaults({});
setProviderConnectedIds([]);
return;
}
let cancelled = false;
const applyProviderState = (value: ProviderListResponse) => {
if (cancelled) return;
// When not signed in, filter out every cloud-managed provider key so
// stale org imports and the hosted `omnirush` catalog do not reappear.
const hasCloudAuth = !!readDenSettings().authToken?.trim();
const all = hasCloudAuth
? ((value.all ?? []) as ProviderListItem[])
: ((value.all ?? []) as ProviderListItem[]).filter(
(provider) => !isCloudManagedProviderKey(provider.id ?? ""),
);
const connected = hasCloudAuth
? (value.connected ?? [])
: (value.connected ?? []).filter((id) => !isCloudManagedProviderKey(id));
setProviders(all);
setProviderConnectedIds(connected);
// New-provider detection is handled globally by the provider auth
// store's applyProviderListState, which fires dispatchNewProviders.
};
void (async () => {
let disabledProviders: string[] = [];
try {
const config = unwrap(
await opencodeClient.config.get({
directory: selectedWorkspaceRoot || undefined,
}),
);
disabledProviders = disabledProvidersFromConfig(config);
if (!cancelled) setDisabledProviderIds(disabledProviders);
} catch {
// ignore config read failures and continue with provider discovery
}
try {
applyProviderState(
filterProviderList(
await ensureProviderListQuery(getReactQueryClient(), {
client: opencodeClient,
baseUrl: opencodeBaseUrl,
directory: selectedWorkspaceRoot || undefined,
}),
disabledProviders,
),
);
} catch {
if (cancelled) return;
setProviders([]);
setProviderDefaults({});
setProviderConnectedIds([]);
}
})();
return () => {
cancelled = true;
};
}, [opencodeBaseUrl, opencodeClient, selectedWorkspaceRoot, denSessionVersion]);
const modelLabel = local.prefs.defaultModel
? resolveModelDisplayName(local.prefs.defaultModel.modelID)
: t("session.default_model");
const listSlashCommands = useCallback(async (): Promise<SlashCommandOption[]> => {
// engineReloadVersion is included so the callback identity changes after
// an engine reload, which invalidates the composer's command list cache
// and causes it to re-fetch (picking up newly created skills).
void engineReloadVersion;
if (!opencodeClient) return [];
return listCommands(opencodeClient, selectedWorkspaceRoot || undefined);
}, [engineReloadVersion, opencodeClient, selectedWorkspaceRoot]);
// Shared by the composer (plug menu, @ mentions) and the command palette.
// Hidden and subagent-only entries are excluded — those are task-tool
// delegation targets, not agents the user can run a session as.
const listAgents = useCallback(async () => {
// Include engineReloadVersion so the composer refetches after newly added
// agent files become available, even when the inline picker is hidden.
void engineReloadVersion;
if (!opencodeClient) return [];
const list = unwrap(await opencodeClient.app.agents());
return list.filter(isLibraryAgent);
}, [engineReloadVersion, opencodeClient]);
const handleOpenSettings = useCallback((route = "/settings/general", workspaceId = sidebarActiveWorkspaceId) => {
const sessionId = workspaceId === sidebarActiveWorkspaceId ? selectedSessionId : null;
const tab = route.replace(/^\/settings\/?/, "").replace(/^\/+|\/+$/g, "") || "general";
const target = workspaceId ? workspaceSettingsRoute(workspaceId, tab) : route;
writeActiveWorkspaceId(workspaceId || null);
navigate(target, { state: { workspaceId, sessionId } });
}, [navigate, selectedSessionId, sidebarActiveWorkspaceId]);
const handleOpenExtensions = useCallback((path = "", workspaceId = sidebarActiveWorkspaceId) => {
const sessionId = workspaceId === sidebarActiveWorkspaceId ? selectedSessionId : null;
const extensionPath = path
.replace(/^\/settings\/extensions\/?/, "")
.replace(/^\/extensions\/?/, "")
.replace(/^\/+|\/+$/g, "")
.replace(/^mcp$/, "mcps");
const target = workspaceId
? workspaceExtensionsRoute(workspaceId, extensionPath)
: globalExtensionsRoute(extensionPath);
writeActiveWorkspaceId(workspaceId || null);
navigate(target, { state: { workspaceId, sessionId } });
}, [navigate, selectedSessionId, sidebarActiveWorkspaceId]);
const extensionsMainOpen = /^\/(?:workspace\/[^/]+\/)?extensions(?:\/|$)/.test(location.pathname);
const surfaceProps = useMemo(() => {
if (!client || !selectedWorkspaceId || !selectedSessionId || !opencodeBaseUrl || !token || !opencodeClient) {
return null;
}
// Transient-safety: when the user switches workspaces the URL-driven
// selectedSessionId may still point at a session from the old workspace
// for one render tick. Only block rendering when we KNOW the session
// belongs to a different workspace (i.e., it exists in another
// workspace's list). A brand-new session that hasn't been refreshed
// into any list yet must still render so "New task" feels instant.
let sessionOwnedByOtherWorkspace = false;
for (const [workspaceId, sessions] of Object.entries(sessionsByWorkspaceId)) {
if (workspaceId === selectedWorkspaceId) continue;
if ((sessions ?? []).some((session) => session?.id === selectedSessionId)) {
sessionOwnedByOtherWorkspace = true;
break;
}
}
if (sessionOwnedByOtherWorkspace) {
return null;
}
// Note: do NOT include `client`, `workspaceId`, `sessionId`,
// `opencodeBaseUrl`, or `omnirushToken` here. SessionPage forwards those
// explicitly to SessionSurface from the per-workspace endpoint resolved
// by `resolveWorkspaceEndpoint`. If we leak them in here, the spread of
// `surfaceProps` in SessionPage overrides those correct values with the
// local server's, and remote workspaces silently end up calling the
// local server with the local `rem_*` id.
return {
mcpDisabled: true,
workspaceRoot: selectedWorkspaceRoot,
draftScope: sessionDraftScope,
developerMode,
modelLabel,
onModelClick: (sessionId?: string) => {
setModelPickerSessionId(sessionId ?? null);
modelPicker.setQuery("");
modelPicker.setOpen(true);
},
providerCatalog,
modelPickerOpen: modelPicker.compactOpen,
// Legacy fallback only; each surface resolves availability for its own
// effective session model through `resolveModelAvailability`.
modelUnavailable: selectedModelUnavailable,
modelUnavailableMessage,
resolveModelAvailability,
organizationModelsEmpty,
selectedModel: projectDefaultModel ?? { providerID: "", modelID: "" },
omniRushModelsEntitled,
omniRushModelsSyncing,
onRefreshOrganizationModels: refreshOrganizationModelAccess,
onModelPickerOpenChange: (open: boolean) => {
modelPicker.setCompactOpen(open);
if (open) {
void refreshCloudProviderSync("model_picker_open");
}
},
onModelChange: (model: ModelRef, variant?: string | null) => {
local.setPrefs((previous) => ({
...previous,
defaultModel: model,
modelVariant: variant !== undefined
? variant
: previous.defaultModel?.providerID === model.providerID && previous.defaultModel.modelID === model.modelID
? previous.modelVariant
: null,
}));
modelPicker.setCompactOpen(false);
},
providerConnectedCount: hasUsableModel ? 1 : providerConnectedIds.length,
onOpenSettingsSection: (section: ComposerSettingsSection) => {
openComposerConfigure(section, {
openLibrary: handleOpenExtensions,
openSettings: handleOpenSettings,
});
},
onSendDraft: async (draft: ComposerDraft, sessionId: string, onPrepared?: () => void): Promise<CloudMcpSubmissionResult> => {
const targetSessionId = sessionId.trim() || selectedSessionId;
if (!targetSessionId) return { outcome: "cancelled", reason: "context_changed" };
const generation = getQueuedSendGeneration(targetSessionId);
const assertCurrent = () => assertQueuedSendCurrent(targetSessionId, generation);
const text = (draft.resolvedText ?? draft.text).trim();
if (!text && draft.attachments.length === 0) {
return { outcome: "cancelled", reason: "context_changed" };
}
// Per-conversation model memory: a session that picked its own model
// sends with it (and its variant) instead of the global default.
const sessionModelSelection = getSessionModelSelection(targetSessionId);
const configuredSendModel = modeSendModel(sessionModelSelection?.model ?? local.prefs.defaultModel, targetSessionId);
const sendModel = configuredSendModel;
// The effort the picker shows for this model, never a null it hides.
const sendVariant = resolveSendVariant(sendModel, sessionModelSelection ? sessionModelSelection.variant : modelVariantValue);
// Send-time validation targets the exact provider/model identity this
// conversation displays and will submit — not the global default.
if (resolveModelAvailability(sendModel ?? null).status === "unavailable") {
throw new Error("Selected model is unavailable. Choose another model before sending.");
}
return submitWithCloudMcpReadiness({
// Temporarily bypass the pre-send Cloud MCP gate: it blocks every
// message, including tasks that do not use connected services.
skipGate: true,
send: async () => {
await sendWithRevertRollback({
assertCurrent,
revertMessageId: draft.revertMessageId,
abort: () => abortSessionSafe(opencodeClient, targetSessionId, selectedWorkspaceRoot || undefined, {
source: "session.edit_resend.before_revert",
initiator: "user",
reason: "abort active run before replacing a reverted message",
}),
revert: async (messageId) => {
const reverted = await revertSession(opencodeClient, targetSessionId, messageId);
applySessionRevert(selectedWorkspaceId, reverted);
},
prompt: async () => {
captureAnalyticsEvent("task_message_sent", {
mode: draft.mode ?? "prompt",
is_command: Boolean(draft.command),
attachment_count: draft.attachments.length,
text_length: text.length,
workspace_type: selectedWorkspace?.workspaceType ?? "unknown",
provider_id: sendModel?.providerID ?? null,
model_id: sendModel?.modelID ?? null,
});
markTaskRunStart(targetSessionId);
// Den org adoption signals (auth-gated inside; no-op when signed out).
// This remains inside the post-readiness send closure so a blocked
// Cloud submission cannot create a run or report that one started.
const projectDimension = readWorkspaceProjectDimension(selectedWorkspaceId);
const modelSelection = sessionModelSelection ? "manual" : "default";
const telemetryDimensions = [
...(projectDimension ? [{
type: "project",
label: projectDimension.label,
}] : []),
...(sendModel ? [{
type: "model",
value: `${sendModel.providerID}/${sendModel.modelID}`,
label: `${sendModel.providerID}/${sendModel.modelID}`,
}] : []),
{
type: "model_selection",
value: modelSelection,
label: modelSelection,
},
];
trackSessionActive(targetSessionId, telemetryDimensions);
trackTaskStarted(targetSessionId, telemetryDimensions);
if (draft.mode === "shell") {
onPrepared?.();
await shellInSession(opencodeClient, targetSessionId, text, { messageID: draft.messageId });
return;
}
if (draft.command) {
onPrepared?.();
const result = await opencodeClient.session.command({
sessionID: targetSessionId,
messageID: draft.messageId,
command: draft.command.name,
arguments: draft.command.arguments,
...(sendVariant ? { variant: sendVariant } : {}),
});
if (result.error) {
throw new Error(serializeSDKError(result.error));
}
return;
}
const parts = await draftToParts(draft, selectedWorkspaceRoot, targetSessionId, selectedWorkspaceEndpoint);
assertCurrent();
const system = await buildOmniRushSessionSystemContext(client, {
workspaceId: selectedWorkspaceId,
cacheKey: targetSessionId,
runtimeKey: environmentRuntimeKey,
});
assertCurrent();
onPrepared?.();
const result = await opencodeClient.session.promptAsync({
sessionID: targetSessionId,
messageID: draft.messageId,
parts,
model: sendModel ?? undefined,
agent: selectedAgent ?? undefined,
...(sendVariant ? { variant: sendVariant } : {}),
system,
});
if (result.error) {
if (isPromptAdmissionUnknown(result.error)) throw result.error;
throw new Error(serializeSDKError(result.error));
}
// Remember what this conversation used last so returning to it
// (or splitting it beside another session) keeps its own model.
if (sendModel && getQueuedSendGeneration(targetSessionId) === generation) {
useSessionModelStore.getState().setModel(targetSessionId, sendModel, sendVariant ?? null);
}
// Its first prompt went out: the chat keeps this model from now on.
markChatStarted(targetSessionId);
},
unrevert: async () => {
try {
await unrevertSession(opencodeClient, targetSessionId);
} finally {
applySessionUnrevert(selectedWorkspaceId, targetSessionId);
}
},
onUnrevertError: (error) => console.warn("[edit-resend] rollback failed", error),
});
},
});
},
cloudMcpSubmissionState,
onOpenConnect: () => handleOpenExtensions(),
onDraftChange: () => {
// Draft persistence will be wired once the full React shell owns session state.
},
attachmentsEnabled: true,
attachmentsDisabledReason: null,
modelVariantLabel,
modelVariant: modelVariantValue,
modelBehaviorOptions,
onModelVariantChange: (value: string | null) => {
local.setPrefs((previous) => ({ ...previous, modelVariant: value }));
},
agentLabel: selectedAgent ? selectedAgent.charAt(0).toUpperCase() + selectedAgent.slice(1) : t("session.default_agent"),
selectedAgent,
listAgents,
onSelectAgent: (agent: string | null) => setSelectedAgent(agent),
listCommands: listSlashCommands,
recentFiles: [],
searchFiles: async (query: string) => {
const trimmed = query.trim();
if (!trimmed) return [];
const result = unwrap(
await opencodeClient.find.files({
query: trimmed,
dirs: "true",
limit: 50,
directory: selectedWorkspaceRoot || undefined,
}),
);
return result;
},
isRemoteWorkspace: selectedWorkspace?.workspaceType === "remote",
isSandboxWorkspace: selectedWorkspace ? isSandboxWorkspace(selectedWorkspace) : false,
onRevertToMessage: async (messageId: string, sessionId: string) => {
const targetSessionId = sessionId.trim() || selectedSessionId;
if (!targetSessionId) return false;
try {
// Abort any running generation first; OpenCode rejects revert on busy sessions.
await abortSessionSafe(opencodeClient, targetSessionId, selectedWorkspaceRoot || undefined, {
source: "session.revert_to_message.before_revert",
initiator: "user",
reason: "abort active run before reverting transcript",
});
const reverted = await revertSession(opencodeClient, targetSessionId, messageId);
// Stamp the revert cursor into the local caches so the transcript
// rewinds immediately instead of waiting for a full reload.
applySessionRevert(selectedWorkspaceId, reverted);
return true;
} catch (error) {
console.warn("[revert] failed", error);
toast.error(t("session.revert_failed"));
return false;
}
},
onRestoreRevertedSession: async (sessionId: string) => {
const targetSessionId = sessionId.trim() || selectedSessionId;
if (!targetSessionId) return false;
try {
await unrevertSession(opencodeClient, targetSessionId);
applySessionUnrevert(selectedWorkspaceId, targetSessionId);
return true;
} catch (error) {
console.warn("[unrevert] failed", error);
toast.error(t("session.restore_failed"));
return false;
}
},
onForkAtMessage: (messageId: string | null, sessionId: string) => {
void (async () => {
const targetSessionId = sessionId.trim() || selectedSessionId;
if (!targetSessionId) return;
try {
const forked = await forkSession(opencodeClient, targetSessionId, messageId ?? undefined);
writeLastSessionFor(selectedWorkspaceId, forked.id);
rememberPendingCreatedSession(selectedWorkspaceId, forked.id);
setSessionsByWorkspaceId((current) => ({
...current,
[selectedWorkspaceId]: mergeWorkspaceRouteSession(current[selectedWorkspaceId] ?? [], forked),
}));
navigateToWorkspaceSession(selectedWorkspaceId, forked.id);
void refreshRouteState();
} catch (error) {
console.warn("[fork] failed", error);
toast.error(t("session.branch_failed"));
}
})();
},
onChangeModel: (model: { providerID: string; modelID: string }) => {
local.setPrefs((previous) => ({
...previous,
defaultModel: model,
modelVariant: previous.defaultModel?.providerID === model.providerID && previous.defaultModel.modelID === model.modelID
? previous.modelVariant
: null,
}));
},
environmentRuntimeKey,
onApplyEnvironmentChanges: isDesktopRuntime() && selectedWorkspace?.workspaceType !== "remote"
? handleApplyEnvironmentChanges
: undefined,
onSessionMissing: forgetMissingSession,
};
}, [
client,
forgetMissingSession,
modelPicker.compactOpen,
handleOpenExtensions,
handleOpenSettings,
hasUsableModel,
handleApplyEnvironmentChanges,
environmentRuntimeKey,
local,
listAgents,
listSlashCommands,
modelBehaviorOptions,
cloudMcpSubmissionState,
developerMode,
modelLabel,
modelUnavailableMessage,
organizationModelsEmpty,
projectDefaultModel,
modelVariantLabel,
modelVariantValue,
navigate,
providerCatalog,
omniRushModelsEntitled,
omniRushModelsSyncing,
refreshCloudProviderSync,
refreshOrganizationModelAccess,
resolveModelAvailability,
opencodeBaseUrl,
opencodeClient,
providerConnectedIds,
selectedAgent,
selectedSessionId,
sessionDraftScope,
selectedModelUnavailable,
selectedWorkspace,
selectedWorkspaceId,
selectedWorkspaceRoot,
sessionsByWorkspaceId,
submitWithCloudMcpReadiness,
token,
]);
const resolvePaneRuntime = useCallback((session: OpenSessionTab): SessionPagePaneRuntime => {
const candidateWorkspace = workspaces.find((candidate) => candidate.id === session.workspaceId);
const workspaceTitle = session.workspaceTitle?.trim()
|| (candidateWorkspace ? workspaceLabel(candidateWorkspace) : session.workspaceId);
const connection = candidateWorkspace ? workspaceConnectionStateById[candidateWorkspace.id] : undefined;
const workspaceError = candidateWorkspace ? errorsByWorkspaceId[candidateWorkspace.id]?.trim() : undefined;
const paneEndpoint = resolveWorkbenchPaneEndpoint({
workspaceId: session.workspaceId,
workspaceTitle,
workspace: candidateWorkspace,
endpoint: endpointForWorkspace(candidateWorkspace),
connectionError: connection?.status === "error" ? connection.message : workspaceError,
});
if (paneEndpoint.status === "unavailable") return paneEndpoint;
const { endpoint, workspace } = paneEndpoint;
if (paneEndpoint.workspaceId === selectedWorkspaceId && surfaceProps) {
return {
status: "ready",
workspaceId: paneEndpoint.workspaceId,
workspaceTitle: paneEndpoint.workspaceTitle,
workspaceRoot: selectedWorkspaceRoot,
workspaceType: paneEndpoint.workspaceType,
runtimeWorkspaceId: endpoint.workspaceId,
opencodeBaseUrl: endpoint.opencodeBaseUrl,
omnirushToken: endpoint.token,
client: endpoint.client,
environmentClient: client,
surface: surfaceProps,
};
}
if (!surfaceProps) {
return {
status: "unavailable",
workspaceId: paneEndpoint.workspaceId,
workspaceTitle: paneEndpoint.workspaceTitle,
message: "The session runtime is still preparing.",
};
}
const workspaceRoot = paneEndpoint.workspaceRoot;
const workspaceOpencodeClient = createClientV2(
endpoint.opencodeBaseUrl,
workspaceRoot || undefined,
{ token: endpoint.token },
);
const scopedSurface = {
...surfaceProps,
workspaceRoot,
modelUnavailable: false,
modelUnavailableMessage: null,
resolveModelAvailability: undefined,
cloudMcpSubmissionState: IDLE_CLOUD_MCP_SUBMISSION_GATE_STATE,
onOpenSettingsSection: (section: ComposerSettingsSection) => {
openComposerConfigure(section, {
openLibrary: (path) => handleOpenExtensions(path, workspace.id),
openSettings: (path) => handleOpenSettings(path, workspace.id),
});
},
onOpenConnect: () => handleOpenExtensions("", workspace.id),
listCommands: async (): Promise<SlashCommandOption[]> => {
void engineReloadVersion;
return listCommands(workspaceOpencodeClient, workspaceRoot || undefined);
},
listAgents: async () => {
void engineReloadVersion;
return unwrap(await workspaceOpencodeClient.app.agents()).filter(isLibraryAgent);
},
searchFiles: async (query: string) => {
const trimmed = query.trim();
if (!trimmed) return [];
return unwrap(await workspaceOpencodeClient.find.files({
query: trimmed,
dirs: "true",
limit: 50,
directory: workspaceRoot || undefined,
}));
},
isRemoteWorkspace: workspace.workspaceType === "remote",
isSandboxWorkspace: isSandboxWorkspace(workspace),
environmentRuntimeKey: workspace.workspaceType === "remote" ? null : environmentRuntimeKey,
onApplyEnvironmentChanges: undefined,
onSendDraft: async (draft: ComposerDraft, sessionId: string, onPrepared?: () => void): Promise<CloudMcpSubmissionResult> => {
const targetSessionId = sessionId.trim() || session.sessionId;
const generation = getQueuedSendGeneration(targetSessionId);
const assertCurrent = () => assertQueuedSendCurrent(targetSessionId, generation);
const text = (draft.resolvedText ?? draft.text).trim();
if (!targetSessionId || (!text && draft.attachments.length === 0)) {
return { outcome: "cancelled", reason: "context_changed" };
}
const sessionModelSelection = getSessionModelSelection(targetSessionId);
const remembered = sessionModelSelection?.model ?? local.prefs.defaultModel;
// The open project's mode rules apply to its own chats (another project's go to the broker, which refuses).
const configuredSendModel = workspace.id === selectedWorkspaceId ? modeSendModel(remembered, targetSessionId) : remembered;
const sendModel = configuredSendModel;
// The effort the picker shows for this model, never a null it hides.
const sendVariant = resolveSendVariant(sendModel, sessionModelSelection ? sessionModelSelection.variant : modelVariantValue);
return submitWithCloudMcpReadiness({
skipGate: true,
send: async () => {
await sendWithRevertRollback({
assertCurrent,
revertMessageId: draft.revertMessageId,
abort: () => abortSessionSafe(workspaceOpencodeClient, targetSessionId, workspaceRoot || undefined, {
source: "session.edit_resend.before_revert",
initiator: "user",
reason: "abort active run before replacing a reverted message",
}),
revert: async (messageId) => {
const reverted = await revertSession(workspaceOpencodeClient, targetSessionId, messageId);
applySessionRevert(endpoint.workspaceId, reverted);
},
prompt: async () => {
captureAnalyticsEvent("task_message_sent", {
mode: draft.mode ?? "prompt",
is_command: Boolean(draft.command),
attachment_count: draft.attachments.length,
text_length: text.length,
workspace_type: workspace.workspaceType ?? "unknown",
provider_id: sendModel?.providerID ?? null,
model_id: sendModel?.modelID ?? null,
});
markTaskRunStart(targetSessionId);
const projectDimension = readWorkspaceProjectDimension(workspace.id);
const modelSelection = sessionModelSelection ? "manual" : "default";
const telemetryDimensions = [
...(projectDimension ? [{ type: "project", label: projectDimension.label }] : []),
...(sendModel ? [{
type: "model",
value: `${sendModel.providerID}/${sendModel.modelID}`,
label: `${sendModel.providerID}/${sendModel.modelID}`,
}] : []),
{ type: "model_selection", value: modelSelection, label: modelSelection },
];
trackSessionActive(targetSessionId, telemetryDimensions);
trackTaskStarted(targetSessionId, telemetryDimensions);
if (draft.mode === "shell") {
onPrepared?.();
await shellInSession(workspaceOpencodeClient, targetSessionId, text, { messageID: draft.messageId });
return;
}
if (draft.command) {
onPrepared?.();
const result = await workspaceOpencodeClient.session.command({
sessionID: targetSessionId,
messageID: draft.messageId,
command: draft.command.name,
arguments: draft.command.arguments,
...(sendVariant ? { variant: sendVariant } : {}),
});
if (result.error) throw new Error(serializeSDKError(result.error));
return;
}
const parts = await draftToParts(draft, workspaceRoot, targetSessionId, endpoint);
assertCurrent();
const system = await buildOmniRushSessionSystemContext(endpoint.client, {
workspaceId: workspace.id,
cacheKey: targetSessionId,
runtimeKey: workspace.workspaceType === "remote" ? null : environmentRuntimeKey,
});
assertCurrent();
onPrepared?.();
const result = await workspaceOpencodeClient.session.promptAsync({
sessionID: targetSessionId,
messageID: draft.messageId,
parts,
model: sendModel ?? undefined,
agent: selectedAgent ?? undefined,
...(sendVariant ? { variant: sendVariant } : {}),
system,
});
if (result.error) {
if (isPromptAdmissionUnknown(result.error)) throw result.error;
throw new Error(serializeSDKError(result.error));
}
if (sendModel && getQueuedSendGeneration(targetSessionId) === generation) {
useSessionModelStore.getState().setModel(targetSessionId, sendModel, sendVariant ?? null);
}
// Its first prompt went out: the chat keeps this model from now on.
markChatStarted(targetSessionId);
},
unrevert: async () => {
try {
await unrevertSession(workspaceOpencodeClient, targetSessionId);
} finally {
applySessionUnrevert(endpoint.workspaceId, targetSessionId);
}
},
onUnrevertError: (error) => console.warn("[edit-resend] rollback failed", error),
});
},
});
},
onRevertToMessage: async (messageId: string, sessionId: string) => {
const targetSessionId = sessionId.trim() || session.sessionId;
try {
await abortSessionSafe(workspaceOpencodeClient, targetSessionId, workspaceRoot || undefined, {
source: "session.revert_to_message.before_revert",
initiator: "user",
reason: "abort active run before reverting transcript",
});
const reverted = await revertSession(workspaceOpencodeClient, targetSessionId, messageId);
applySessionRevert(endpoint.workspaceId, reverted);
return true;
} catch (error) {
console.warn("[revert] failed", error);
toast.error(t("session.revert_failed"));
return false;
}
},
onRestoreRevertedSession: async (sessionId: string) => {
const targetSessionId = sessionId.trim() || session.sessionId;
try {
await unrevertSession(workspaceOpencodeClient, targetSessionId);
applySessionUnrevert(endpoint.workspaceId, targetSessionId);
return true;
} catch (error) {
console.warn("[unrevert] failed", error);
toast.error(t("session.restore_failed"));
return false;
}
},
onForkAtMessage: (messageId: string | null, sessionId: string) => {
void (async () => {
const targetSessionId = sessionId.trim() || session.sessionId;
try {
const forked = await forkSession(workspaceOpencodeClient, targetSessionId, messageId ?? undefined);
writeLastSessionFor(workspace.id, forked.id);
rememberPendingCreatedSession(workspace.id, forked.id);
setSessionsByWorkspaceId((current) => ({
...current,
[workspace.id]: mergeWorkspaceRouteSession(current[workspace.id] ?? [], forked),
}));
navigateToWorkspaceSession(workspace.id, forked.id);
void refreshRouteState();
} catch (error) {
console.warn("[fork] failed", error);
toast.error(t("session.branch_failed"));
}
})();
},
};
return {
status: "ready",
workspaceId: paneEndpoint.workspaceId,
workspaceTitle: paneEndpoint.workspaceTitle,
workspaceRoot,
workspaceType: paneEndpoint.workspaceType,
runtimeWorkspaceId: endpoint.workspaceId,
opencodeBaseUrl: endpoint.opencodeBaseUrl,
omnirushToken: endpoint.token,
client: endpoint.client,
environmentClient: client,
surface: scopedSurface,
};
}, [
client,
endpointForWorkspace,
engineReloadVersion,
environmentRuntimeKey,
errorsByWorkspaceId,
handleOpenExtensions,
handleOpenSettings,
local.prefs.defaultModel,
modelVariantValue,
navigateToWorkspaceSession,
refreshRouteState,
rememberPendingCreatedSession,
selectedAgent,
selectedWorkspaceId,
selectedWorkspaceRoot,
setSessionsByWorkspaceId,
submitWithCloudMcpReadiness,
surfaceProps,
workspaceConnectionStateById,
workspaces,
]);
const cloudWorkspaceMainContentDecision = mapCloudWorkspaceMainContentDecision({
status: cloudWorkspace.viewModel.variant,
hasWorkspaces: Boolean(surfaceProps),
gatewayMode: cloudWorkspace.gatewayMode && cloudWorkspace.visible,
});
const cloudWorkspaceReadyForRouteErrors =
!cloudWorkspace.gatewayMode ||
!cloudWorkspace.visible ||
cloudWorkspaceStatusHasReadyContent(cloudWorkspace.viewModel.variant);
const cloudWorkspaceMainContentTakeover = cloudWorkspaceMainContentDecision === "takeover" ? (
<CloudWorkspaceBootTakeover decision={cloudWorkspaceMainContentDecision} />
) : null;
const gatedRouteNotFoundMessage = cloudWorkspaceReadyForRouteErrors ? routeNotFoundMessage : null;
// Workspace-scoped wiring for the empty-state hero's full composer. Unlike
// `surfaceProps` this exists without a selected session, so the hero offers
// the same skills/commands/agent/model controls before the session is
// created. Model and agent choices land in the same route-level state the
// session composer reads, so they carry into the created session.
const newTaskComposerContext = useMemo<NewTaskComposerContext | null>(() => {
return {
client,
workspaceId: selectedWorkspaceId || null,
draftOwnerKey: JSON.stringify([
sessionDraftScope,
selectedWorkspaceEndpoint?.opencodeBaseUrl ?? null,
selectedWorkspaceId || null,
]),
draftScope: sessionDraftScope,
selectedModel: local.prefs.defaultModel ?? { providerID: "", modelID: "" },
modelOptions: organizationAssignedModelOptions,
modelUnavailable: selectedModelUnavailable,
modelUnavailableMessage,
organizationModelsEmpty,
onRefreshOrganizationModels: refreshOrganizationModelAccess,
modelPickerOpen: modelPicker.compactOpen,
onModelPickerOpenChange: (open: boolean) => {
modelPicker.setCompactOpen(open);
if (open) {
void sessionProviderAuthStore.refreshCloudOrgProviders({ force: true }).catch(() => undefined);
void refreshCloudProviderSync("model_picker_open");
}
},
onModelChange: (model: ModelRef, variant?: string | null) => {
local.setPrefs((previous) => ({
...previous,
defaultModel: model,
modelVariant: variant !== undefined
? variant
: previous.defaultModel?.providerID === model.providerID && previous.defaultModel.modelID === model.modelID
? previous.modelVariant
: null,
}));
modelPicker.setCompactOpen(false);
},
omniRushModelsEntitled,
omniRushModelsSyncing,
modelVariantLabel,
modelVariant: modelVariantValue,
modelBehaviorOptions,
onModelVariantChange: (value: string | null) => {
local.setPrefs((previous) => ({ ...previous, modelVariant: value }));
},
agentLabel: selectedAgent ? selectedAgent.charAt(0).toUpperCase() + selectedAgent.slice(1) : t("session.default_agent"),
selectedAgent,
listAgents,
onSelectAgent: (agent: string | null) => setSelectedAgent(agent),
listCommands: listSlashCommands,
searchFiles: async (query: string) => {
const trimmed = query.trim();
if (!trimmed || !opencodeClient) return [];
const result = unwrap(
await opencodeClient.find.files({
query: trimmed,
dirs: "true",
limit: 50,
directory: selectedWorkspaceRoot || undefined,
}),
);
return result;
},
isRemoteWorkspace: selectedWorkspace?.workspaceType === "remote",
isSandboxWorkspace: selectedWorkspace ? isSandboxWorkspace(selectedWorkspace) : false,
onOpenSettingsSection: (section: ComposerSettingsSection) => {
openComposerConfigure(section, {
openLibrary: handleOpenExtensions,
openSettings: handleOpenSettings,
});
},
};
}, [
client,
handleOpenExtensions,
handleOpenSettings,
listAgents,
listSlashCommands,
local,
modelUnavailableMessage,
modelBehaviorOptions,
modelPicker,
modelVariantLabel,
modelVariantValue,
opencodeClient,
omniRushModelsEntitled,
omniRushModelsSyncing,
organizationAssignedModelOptions,
organizationModelsEmpty,
refreshCloudProviderSync,
refreshOrganizationModelAccess,
selectedAgent,
selectedModelUnavailable,
selectedWorkspace,
selectedWorkspaceEndpoint,
selectedWorkspaceId,
selectedWorkspaceRoot,
sessionDraftScope,
sessionProviderAuthStore,
setSelectedAgent,
]);
const handleOpenCreateWorkspace = useCallback(() => {
if (!canCreateWorkspaces()) return;
// Respect the org-level `allowMultipleWorkspaces` restriction (dev
// #1505). If the checker returns true, the admin has disabled
// adding further workspaces; surface a friendly notice instead of
// opening the modal.
if (
workspaces.length > 0 &&
checkDesktopRestriction({ restriction: "allowMultipleWorkspaces" })
) {
restrictionNotice.show({
title: "Additional workspaces are restricted",
message:
"Your organization administrator has restricted access to adding additional workspaces.",
});
return;
}
setCreateWorkspaceRemoteError(null);
setCreateWorkspaceOpen(true);
}, [checkDesktopRestriction, restrictionNotice, workspaces.length]);
const handleOpenRenameWorkspace = useCallback((workspaceId: string) => {
const workspace = workspaces.find((item) => item.id === workspaceId);
if (!workspace) return;
setRenameWorkspaceId(workspaceId);
setRenameWorkspaceTitle(
workspace.displayName?.trim() ||
workspace.name?.trim() ||
workspace.path?.trim() ||
"",
);
}, [workspaces]);
const handleSaveRenameWorkspace = useCallback(async () => {
if (!renameWorkspaceId) return;
const trimmed = renameWorkspaceTitle.trim();
if (!trimmed) return;
setRenameWorkspaceBusy(true);
try {
if (!client) {
toast.error("omnirush.ai server is unavailable. Reconnect the server before renaming workspaces.");
return;
}
await client.updateWorkspaceDisplayName(renameWorkspaceId, trimmed);
setRenameWorkspaceId(null);
setRenameWorkspaceTitle("");
await refreshRouteState();
} catch (error) {
toast.error("Workspace rename failed", {
description: describeRouteError(error),
});
} finally {
setRenameWorkspaceBusy(false);
}
}, [client, refreshRouteState, renameWorkspaceId, renameWorkspaceTitle]);
const handleRevealWorkspace = useCallback(async (workspaceId: string) => {
const workspace = workspaces.find((item) => item.id === workspaceId);
const path = workspace?.path?.trim();
if (!path || !isDesktopRuntime()) return;
try {
await revealDesktopItemInDir(path);
} catch {
// ignore
}
}, [workspaces]);
const handleShareWorkspace = useCallback((workspaceId: string) => {
shareWorkspaceState.openShareWorkspace(workspaceId);
}, [shareWorkspaceState]);
const handleSaveShareRemoteAccess = useCallback(
async (enabled: boolean) => {
if (!isDesktopRuntime()) return;
await remoteAccessRestart.save(enabled);
},
[remoteAccessRestart],
);
const handleExportWorkspaceConfig = useCallback(
async (workspaceId: string) => {
const workspace = workspaces.find((item) => item.id === workspaceId) ?? null;
if (!workspace) return;
const endpoint = endpointForWorkspace(workspace);
if (endpoint) {
const payload = await endpoint.client.exportWorkspace(endpoint.workspaceId);
downloadWorkspaceJson(workspaceExportFilename(workspace), payload);
return;
}
throw new Error("omnirush.ai server is unavailable. Reconnect the server before exporting workspace config.");
},
[endpointForWorkspace, workspaces],
);
const removeWorkspaceConfirmed = useCallback(
async (workspaceId: string): Promise<void> => {
// Remove from both stores so the next refresh can't resurrect the row
// from whichever list wins the merge.
try {
await removeRouteWorkspace({
workspaceId,
deleteFromServer: client ? (id) => client.deleteWorkspace(id) : null,
forgetOnDesktop: isDesktopRuntime() ? workspaceForget : null,
closeTerminals: closeWorkspaceTerminals,
});
} catch (error) {
console.error("[session-route] remove workspace failed", error);
toast.error(t("workspace_list.remove_failed"), {
id: `workspace-remove:${workspaceId}`,
duration: 30_000,
description: describeRouteError(error),
action: { label: t("common.retry"), onClick: () => void removeWorkspaceConfirmed(workspaceId) },
});
await refreshRouteState();
return;
}
if (selectedWorkspaceId === workspaceId) {
setLegacySelectedWorkspaceId("");
writeActiveWorkspaceId(null);
navigate(legacySessionRoute());
}
forgetWorkspaceMemory(workspaceId);
sessionManagementStore.getState().forgetWorkspace(workspaceId);
await refreshRouteState();
},
[client, navigate, refreshRouteState, selectedWorkspaceId],
);
const handleForgetWorkspace = useCallback(
async (workspaceId: string) => {
if (typeof window !== "undefined") {
const message =
t("workspace_list.remove_confirm") ||
"Remove this workspace from the sidebar?";
if (!window.confirm(message)) return;
}
await removeWorkspaceConfirmed(workspaceId);
},
[removeWorkspaceConfirmed],
);
const applyLastUsedModelToSession = useCallback((sessionId: string, workspaceId: string) => {
// The open chat's model carries over only inside its own project; another project starts on its own pick or the app default.
const previous = selectedSessionId && workspaceId === selectedWorkspaceId ? getSessionModelSelection(selectedSessionId) : null;
const own = previous ?? getSessionModelSelection(projectModelKey(workspaceId));
const model = own?.model ?? appLocal.prefs.defaultModel;
if (!model?.providerID || !model.modelID) return;
const variant = own ? own.variant : (appLocal.prefs.modelVariant ?? null);
useSessionModelStore.getState().setModel(sessionId, model, variant);
if (previous) rememberProjectModel(workspaceId, previous);
}, [appLocal.prefs.defaultModel, appLocal.prefs.modelVariant, selectedSessionId, selectedWorkspaceId]);
const handleCreateTaskInWorkspaceWithOpenMode = useCallback(async (
workspaceId: string,
openAs: "primary" | "split",
source: "new_task" | "new_split" = openAs === "split" ? "new_split" : "new_task",
): Promise<string | null> => {
const sideChatOwner = openAs === "split" ? useWorkbenchStore.getState().primary : null;
if (openAs === "split" && !sideChatOwner) return null;
const workspace = workspaces.find((item) => item.id === workspaceId);
if (
!workspace ||
loading ||
retryingWorkspaceIds.includes(workspaceId)
) {
return null;
}
const endpoint = endpointForWorkspace(workspace);
if (!endpoint || !endpoint.token) {
return null;
}
const toastId = taskCreateUnavailableToastId(workspaceId);
const attempts = TASK_CREATE_RETRY_DELAYS_MS.length + 1;
try {
setErrorsByWorkspaceId((current) => ({ ...current, [workspaceId]: null }));
setRouteError(null);
// A stalled engine (rollover, overload) misses the 10 s request timeout
// and used to surface as a dead-end "unavailable" toast that only Cmd+R
// seemed to fix. Retry transient failures with a visible countdown first.
const session = await withTransientEngineRetry({
load: () => createRouteSession(endpoint, workspace.path?.trim() || undefined),
retryDelaysMs: TASK_CREATE_RETRY_DELAYS_MS,
onRetry: (attempt) => {
const notice = describeTaskCreateRetry({ developerMode, attempt, attempts });
toast.info(notice.title, {
id: toastId,
description: notice.description,
duration: Infinity,
});
},
});
if (workspaceId === selectedWorkspaceId) {
void refreshCloudProviderSync("new_chat");
}
captureAnalyticsEvent("task_created", {
source,
workspace_type: workspace.workspaceType ?? "unknown",
});
toast.dismiss(taskCreateUnavailableToastId(workspaceId));
toast.dismiss();
if (openAs === "primary") {
setLegacySelectedWorkspaceId(workspaceId);
writeActiveWorkspaceId(workspaceId || null);
writeLastSessionFor(workspaceId, session.id);
}
useComposerStateStore.setState({ pendingFocusSessionId: session.id });
rememberPendingCreatedSession(workspaceId, session.id);
applyLastUsedModelToSession(session.id, workspaceId);
setSessionsByWorkspaceId((current) => {
const next = {
...current,
[workspaceId]: mergeWorkspaceRouteSession(current[workspaceId] ?? [], session),
};
sessionsByWorkspaceIdRef.current = next;
return next;
});
if (openAs === "primary") {
navigateToWorkspaceSession(workspaceId, session.id);
} else {
const tab = {
workspaceId,
workspaceTitle: workspace.displayNameResolved.trim() || workspaceId,
sessionId: session.id,
title: session.title,
};
const workbench = useWorkbenchStore.getState();
workbench.openTab(tab);
if (sideChatOwner) {
workbench.setSideChat(sideChatOwner, tab);
}
}
return session.id;
} catch (error) {
const message = describeTaskCreateError(error);
setRouteError(message);
setErrorsByWorkspaceId((current) => ({ ...current, [workspaceId]: message }));
const failure = describeTaskCreateFailure(error, attempts);
toast.error(failure.title, {
id: toastId,
description: failure.description,
action: {
label: "Retry",
onClick: () => void handleCreateTaskInWorkspaceWithOpenMode(workspaceId, openAs, source),
},
// A blue/green reload brings up a fresh engine without killing live
// sessions; the full desktop restart stays a last resort elsewhere.
...(failure.kind === "not_responding"
? {
cancel: {
label: t("session.engine_reload_action"),
onClick: () => {
void reloadEngineWithDesktopFallback(endpoint.client, endpoint.workspaceId)
.then(() => handleCreateTaskInWorkspaceWithOpenMode(workspaceId, openAs, source))
.catch(() => undefined);
},
},
}
: {}),
duration: Infinity,
});
if (isTransientStartupError(message)) {
setRetryingWorkspaceIds((current) => Array.from(new Set([...current, workspaceId])));
if (startupRetryTimerRef.current === null) {
startupRetryTimerRef.current = window.setTimeout(() => {
startupRetryTimerRef.current = null;
void refreshRouteState({ supersede: true });
}, 1_000);
}
}
return null;
}
}, [applyLastUsedModelToSession, developerMode, endpointForWorkspace, loading, navigateToWorkspaceSession, refreshCloudProviderSync, refreshRouteState, rememberPendingCreatedSession, retryingWorkspaceIds, selectedWorkspaceId, workspaces]);
const handleCreateTaskInWorkspace = useCallback((workspaceId: string): Promise<string | null> => {
const { focusedPane, secondary } = useWorkbenchStore.getState();
const openAs = focusedPane === "secondary" && secondary ? "split" : "primary";
return handleCreateTaskInWorkspaceWithOpenMode(workspaceId, openAs, "new_task");
}, [handleCreateTaskInWorkspaceWithOpenMode]);
const handleCreateSplitTaskInWorkspace = useCallback(
(workspaceId: string): Promise<string | null> => handleCreateTaskInWorkspaceWithOpenMode(workspaceId, "split"),
[handleCreateTaskInWorkspaceWithOpenMode],
);
// Latest session-list state for prev/next session tab navigation. The
// `options` field is updated by `onSessionTabsChange` from SessionPage so we
// only cycle through tabs the user actually opened (not artifact sessions).
// The remaining fields are refreshed during render.
const sessionTabNavRef = useRef<{
options: OpenSessionTab[];
workspaceId: string;
sessionId: string | null;
navigate: (workspaceId: string, sessionId?: string | null) => void;
}>({ options: [], workspaceId: "", sessionId: null, navigate: () => {} });
const goToSessionTabByOffset = useCallback((offset: number) => {
const { options, workspaceId, sessionId, navigate } = sessionTabNavRef.current;
const scoped = options.filter((option) => option.workspaceId === workspaceId);
if (scoped.length === 0) return;
const currentIndex = sessionId
? scoped.findIndex((option) => option.sessionId === sessionId)
: -1;
const nextIndex = currentIndex === -1
? offset > 0 ? 0 : scoped.length - 1
: (currentIndex + offset + scoped.length) % scoped.length;
const target = scoped[nextIndex];
if (!target || target.sessionId === sessionId) return;
navigate(target.workspaceId, target.sessionId);
}, []);
const goToNextSessionTab = useCallback(() => goToSessionTabByOffset(1), [goToSessionTabByOffset]);
const goToPrevSessionTab = useCallback(() => goToSessionTabByOffset(-1), [goToSessionTabByOffset]);
const cycleThinkingMode = useCallback((direction: ThinkingModeShortcutDirection = "forward") => {
const workbench = useWorkbenchStore.getState();
const activeSessionId = workbench.focusedPane === "secondary" && workbench.secondary
? workbench.secondary.sessionId
: selectedSessionId;
const selection = activeSessionId ? getSessionModelSelection(activeSessionId) : null;
const summary = selection
? (() => {
const model = providerCatalog?.[selection.model.providerID]?.[selection.model.modelID];
return model
? getModelBehaviorSummary(selection.model.providerID, model, selection.variant)
: null;
})()
: null;
const options = selection ? (summary?.options ?? []) : modelBehaviorOptions;
const current = selection ? (summary?.value ?? selection.variant) : modelVariantValue;
const next = direction === "reverse"
? previousModelBehaviorValue(options, current)
: nextModelBehaviorValue(options, current);
if (!next) return null;
if (activeSessionId && selection) {
useSessionModelStore.getState().setVariant(activeSessionId, next);
}
// Match the composer's existing variant change path: session overrides are
// remembered per conversation and the global fallback follows the choice.
local.setPrefs((previous) => ({ ...previous, modelVariant: next }));
return options.find((option) => option.value === next)?.label ?? next;
}, [local, modelBehaviorOptions, modelVariantValue, providerCatalog, selectedSessionId]);
const cycleThinkingModeControlAction = useMemo<OmniRushControlAction>(() => ({
id: "session.model_variant.cycle",
label: "Cycle thinking mode",
description: "Advance the focused conversation to its next available thinking or reasoning effort.",
sideEffect: "mutation",
execute: () => {
const label = cycleThinkingMode();
return label ? { ok: true, label } : { ok: false, error: "The focused model has fewer than two thinking modes." };
},
}), [cycleThinkingMode]);
useControlAction(cycleThinkingModeControlAction);
const cycleFavoriteModel = useCallback(() => {
const workbench = useWorkbenchStore.getState();
const activeSessionId = workbench.focusedPane === "secondary" && workbench.secondary
? workbench.secondary.sessionId
: selectedSessionId;
const selection = activeSessionId ? getSessionModelSelection(activeSessionId) : null;
const currentModel = selection?.model ?? local.prefs.defaultModel ?? null;
const next = nextFavoriteModel(useModelCollectionsStore.getState().favorites, currentModel);
if (!next) return null;
const providerModel = providerCatalog?.[next.providerID]?.[next.modelID];
const summary = providerModel
? getModelBehaviorSummary(next.providerID, providerModel, selection?.variant ?? modelVariantValue)
: null;
const variant = summary && summary.options.length > 0 ? summary.value : null;
if (activeSessionId) {
useSessionModelStore.getState().setModel(activeSessionId, next, variant);
}
useModelCollectionsStore.getState().recordRecent(next);
local.setPrefs((previous) => ({ ...previous, defaultModel: next, modelVariant: variant }));
return resolveModelDisplayName(next.modelID, providerModel?.name);
}, [local, modelVariantValue, providerCatalog, selectedSessionId]);
const cycleFavoriteModelControlAction = useMemo<OmniRushControlAction>(() => ({
id: "session.favorite_model.cycle",
label: "Cycle favorite model",
description: "Switch the focused conversation to its next favorite model.",
sideEffect: "mutation",
execute: () => {
const label = cycleFavoriteModel();
return label ? { ok: true, label } : { ok: false, error: "Add a favorite model before cycling favorites." };
},
}), [cycleFavoriteModel]);
useControlAction(cycleFavoriteModelControlAction);
const {
commandPaletteOpen,
setCommandPaletteOpen,
sessionSearchOpen,
setSessionSearchOpen,
terminalOpen,
setTerminalOpen,
sessionNumberShortcuts,
} = useShellShortcuts({
canCreateTask,
workspaceId: selectedWorkspaceId,
onCreateTask: (workspaceId: string) => void handleCreateTaskInWorkspace(workspaceId),
onNextSessionTab: goToNextSessionTab,
onPrevSessionTab: goToPrevSessionTab,
onCycleThinkingMode: cycleThinkingMode,
onCycleFavoriteModel: cycleFavoriteModel,
});
useReactRenderWatchdog("SessionRoute", {
selectedSessionId,
selectedWorkspaceId,
loading,
workspaceCount: workspaces.length,
sessionGroupCount: Object.keys(sessionsByWorkspaceId).length,
commandPaletteOpen,
modelPickerOpen: modelPicker.open,
});
const navigateToSessionForControl = useCallback((sessionId: string) => {
const owner = Object.entries(sessionsByWorkspaceId).find(([, sessions]) =>
(sessions ?? []).some((session) => session?.id === sessionId),
)?.[0];
navigateToWorkspaceSession(owner || selectedWorkspaceId, sessionId);
}, [navigateToWorkspaceSession, selectedWorkspaceId, sessionsByWorkspaceId]);
const navigateToSessionRootForControl = useCallback(() => {
navigateToWorkspaceSession(selectedWorkspaceId);
}, [navigateToWorkspaceSession, selectedWorkspaceId]);
const openModelPickerForControl = useCallback(() => {
// Opened while a conversation is visible: target that conversation so the
// picker's checkmark and the selection it writes match the composer.
setModelPickerSessionId(selectedSessionId || null);
modelPicker.setOpen(true);
}, [selectedSessionId]);
useSessionControlActions({
workspaces,
sessionsByWorkspaceId,
selectedWorkspaceId,
selectedWorkspaceRoot,
selectedSessionId,
canCreateTask,
omnirushClient: client,
opencodeClient,
archiveDisabledReason,
endpointForWorkspace,
navigateToSession: navigateToSessionForControl,
navigateToSessionRoot: navigateToSessionRootForControl,
createTaskInWorkspace: handleCreateTaskInWorkspace,
openModelPicker: openModelPickerForControl,
refreshRouteState,
forgetDeletedSession,
});
const seedUnavailableModelControlAction = useMemo<OmniRushControlAction | null>(() => {
if (!import.meta.env.DEV) return null;
return {
id: "eval.model_not_available.seed",
label: "Seed an unavailable selected model",
description: "Dev-only eval hook that selects a missing model and returns an available model to recover with. scope=default leaves the open conversation's remembered model untouched.",
sideEffect: "mutation",
disabled: !opencodeClient,
args: [{ name: "scope", type: "string", description: "default | both (default: both)" }],
execute: async (args) => {
if (!opencodeClient) return { ok: false, error: "omnirush.ai client is not connected." };
const scope = (args && typeof args === "object" && Reflect.get(args, "scope") === "default")
? "default"
: "both";
const providerList = await ensureProviderListQuery(getReactQueryClient(), {
client: opencodeClient,
baseUrl: opencodeBaseUrl,
directory: selectedWorkspaceRoot || undefined,
force: true,
});
const filteredProviderList = filterProviderList(providerList, disabledProviderIds);
const availableProvider = getConnectedProviderItems(filteredProviderList)
.filter((provider) => !isDesktopProviderBlocked({
providerId: provider.id,
checkRestriction: checkDesktopRestriction,
}))
.find((provider) => Object.keys(provider.models ?? {}).length > 0);
const availableModelId = availableProvider ? Object.keys(availableProvider.models ?? {})[0] : undefined;
const availableModel = availableProvider && availableModelId
? availableProvider.models[availableModelId]
: undefined;
if (!availableProvider || !availableModelId || !availableModel) {
return { ok: false, error: "No available connected model found for eval recovery." };
}
const unavailableModel = nextEvalUnavailableModel(local.prefs.defaultModel);
modelPicker.setQuery("");
modelPicker.setRecentProviderIds(new Set());
local.setPrefs((previous) => ({
...previous,
defaultModel: unavailableModel,
modelVariant: null,
}));
// Per-conversation memory is session-scoped: seeding "both" makes the
// open conversation's own model unavailable; "default" reproduces the
// workspace-switch state where only the global default is missing.
if (scope === "both" && selectedSessionId) {
useSessionModelStore.getState().setModel(selectedSessionId, unavailableModel, null);
}
return {
scope,
unavailableModel,
availableModel: {
providerID: availableProvider.id,
providerName: availableProvider.name || availableProvider.id,
modelID: availableModelId,
title: availableModel.name || availableModelId,
},
sessionId: selectedSessionId,
workspaceId: selectedWorkspaceId,
};
},
};
}, [checkDesktopRestriction, disabledProviderIds, local, modelPicker.setQuery, modelPicker.setRecentProviderIds, opencodeBaseUrl, opencodeClient, selectedSessionId, selectedWorkspaceId, selectedWorkspaceRoot]);
useControlAction(seedUnavailableModelControlAction);
const seedActiveSessionSidebarControlAction = useMemo<OmniRushControlAction | null>(() => {
if (!import.meta.env.DEV) return null;
return {
id: "eval.session_sidebar.seed_active",
label: "Show the selected session as active",
description: "Dev-only eval hook that displays the selected session activity spinner.",
sideEffect: "mutation",
disabled: !selectedWorkspaceId || !selectedSessionId,
execute: () => {
if (!selectedWorkspaceId || !selectedSessionId) {
return { ok: false, error: "No session is selected." };
}
useSessionActivityStore.getState().setRunStatus(selectedWorkspaceId, selectedSessionId, "running");
return { workspaceId: selectedWorkspaceId, sessionId: selectedSessionId };
},
};
}, [selectedSessionId, selectedWorkspaceId]);
useControlAction(seedActiveSessionSidebarControlAction);
const seedChildPermissionControlAction = useMemo<OmniRushControlAction | null>(() => {
if (!import.meta.env.DEV) return null;
return {
id: "eval.child_permission.seed",
label: "Seed a child session permission request",
description: "Dev-only eval hook that creates a child session blocked on a permission request.",
sideEffect: "mutation",
disabled: !selectedWorkspaceId || !selectedSessionId,
execute: (args) => {
if (!selectedWorkspaceId || !selectedSessionId) {
return { ok: false, error: "No session is selected." };
}
const parent = (sessionsByWorkspaceId[selectedWorkspaceId] ?? []).find(
(session) => session.id === selectedSessionId,
);
if (!parent) return { ok: false, error: "The selected session is unavailable." };
const browserBranding = typeof args === "object" && args !== null
&& Reflect.get(args, "browserBranding") === true;
const browserTool = "opencode-chrome-devtools_browser_open";
const childSessionId = `${selectedSessionId}:eval-child`;
// Match a real session.created event: a concurrent list snapshot must
// not remove this newly seeded child before its approval is answered.
rememberPendingCreatedSession(selectedWorkspaceId, childSessionId);
const request: PendingPermission = {
id: `${selectedSessionId}:eval-child-permission`,
sessionID: childSessionId,
permission: browserBranding ? browserTool : "bash",
patterns: browserBranding ? [browserTool] : ["git status --short --branch"],
metadata: browserBranding ? {
tool: browserTool,
description: "OpenCode browser access",
} : {
command: "git status --short --branch",
description: "Inspect the delegated task workspace",
},
always: [],
// Keep this deterministic proof request newer than any concurrent
// snapshot so the dev seam behaves like a live post-snapshot event.
receivedAt: Number.MAX_SAFE_INTEGER,
protocol: "legacy",
evaluation: true,
};
setSessionsByWorkspaceId((current) => ({
...current,
[selectedWorkspaceId]: [
...(current[selectedWorkspaceId] ?? []).filter((session) => session.id !== childSessionId),
{
...parent,
id: childSessionId,
title: "Investigate the deployment failure",
parentID: selectedSessionId,
time: { ...parent.time, created: Date.now(), updated: Date.now() },
},
],
}));
const runtimeWorkspaceId = selectedWorkspaceEndpoint?.workspaceId ?? selectedWorkspaceId;
getReactQueryClient().setQueryData<PendingPermission[]>(
permissionKey(runtimeWorkspaceId, childSessionId),
[request],
);
useSessionActivityStore.getState().setWaitingRequest(
runtimeWorkspaceId,
childSessionId,
"permission",
request.id,
true,
);
return { childSessionId };
},
};
}, [rememberPendingCreatedSession, selectedSessionId, selectedWorkspaceEndpoint?.workspaceId, selectedWorkspaceId, sessionsByWorkspaceId, setSessionsByWorkspaceId]);
useControlAction(seedChildPermissionControlAction);
const commandPaletteControlAction = useMemo<OmniRushControlAction>(() => ({
id: "command_palette.open",
label: "Open the command palette",
description: "Open the in-app command palette so the next choice is visible.",
effects: { data: "none", ui: "dialog", external: false },
sideEffect: "none",
execute: () => setCommandPaletteOpen(true),
}), []);
useControlAction(commandPaletteControlAction);
const addProviderControlAction = useMemo<OmniRushControlAction>(() => ({
id: "settings.provider.add",
label: "Add a model provider",
description: "Open the provider connection modal, optionally pre-filtered to a specific provider.",
sideEffect: "mutation",
requiresArgs: false,
args: [
{ name: "providerId", type: "string" as const, required: false, description: "Provider id to pre-select, e.g. 'anthropic', 'openai', 'google'." },
],
execute: async (rawArgs: unknown) => {
const providerId = typeof rawArgs === "object" && rawArgs !== null
? (rawArgs as Record<string, unknown>).providerId
: undefined;
const preferred = typeof providerId === "string" ? providerId.trim() : undefined;
if (sessionProviderAuthStore.isProviderAddRestricted(preferred)) {
return { ok: false, error: isProviderLocked() ? providerLockMessage() : t("providers.custom_providers_disabled") };
}
await sessionProviderAuthStore.openProviderAuthModal(
preferred ? { preferredProviderId: preferred } : undefined,
);
return { ok: true, opened: "provider_auth_modal", preferredProviderId: preferred ?? null };
},
}), [sessionProviderAuthStore]);
useControlAction(addProviderControlAction);
const handleOpenProviderAuth = useCallback(() => {
if (sessionProviderAuthStore.isProviderAddRestricted()) {
restrictionNotice.show({
title: t("restrictions.add_custom_providers_disabled_title"),
message: isProviderLocked() ? providerLockMessage() : t("restrictions.add_custom_providers_disabled_message"),
});
return;
}
// Pre-workspace (chat-first) there is no opencode client yet, so the
// modal cannot load auth methods — fall back to the AI Providers page.
void sessionProviderAuthStore.openProviderAuthModal({ returnFocusTarget: "composer" }).catch(() => {
handleOpenSettings("/settings/ai");
});
}, [handleOpenSettings, restrictionNotice, sessionProviderAuthStore]);
// "Connect more providers" in the compact model picker (and anything else
// outside this route's prop tree) requests the provider auth modal here.
useEffect(() => {
const handler = () => handleOpenProviderAuth();
window.addEventListener(openProviderAuthEvent, handler);
return () => window.removeEventListener(openProviderAuthEvent, handler);
}, [handleOpenProviderAuth]);
const paletteSessionOptions = useMemo(
// Chats of the mode in view only (recent chats on the start screen, the palette).
() => buildCommandPaletteSessions(workspaces.filter((workspace) => shownInMode(workspace, workEnabled, appMode)), sessionsByWorkspaceId, selectedWorkspaceId),
[appMode, sessionsByWorkspaceId, selectedWorkspaceId, workEnabled, workspaces],
);
const paletteSessionModelSelection = selectedSessionId
? getSessionModelSelection(selectedSessionId)
: null;
const paletteSelectedModel = paletteSessionModelSelection?.model
?? local.prefs.defaultModel
?? undefined;
const paletteSelectedModelBehavior = paletteSessionModelSelection
? (() => {
const selected = paletteSessionModelSelection.model;
const model = providerCatalog?.[selected.providerID]?.[selected.modelID];
return model
? getModelBehaviorSummary(
paletteSessionModelSelection.model.providerID,
model,
paletteSessionModelSelection.variant,
).value
: paletteSessionModelSelection.variant;
})()
: modelVariantValue;
// Every list the route shows: the project's allowed models (Claude's come from the engine's Claude provider).
const pickerOptions = useMemo(
() => modelPicker.options.filter((option) => modelModes.allowsNew(option)),
[modelModes, modelPicker.options],
);
// A pick the picker should not just switch to (claude-models.ts decideModelPick).
const [newChatOffer, setNewChatOffer] = useState<{ next: ModelRef; current: ModelRef } | null>(null);
const modelTitle = (ref: ModelRef) => isClaudeModel(ref)
? claudeModelName(useClaudeModels.getState(), ref.modelID)
: modelPicker.options.find((option) => option.providerID === ref.providerID && option.modelID === ref.modelID)?.title ?? resolveModelDisplayName(ref.modelID);
/** Claude runs in the sandbox: set the project's sandbox up (as the required sandbox does) before its first turn. */
const setUpSandboxForClaude = () => {
const endpoint = selectedWorkspaceEndpoint;
if (!endpoint?.client) return;
void setUpClaudeSandbox(endpoint.client, endpoint.workspaceId).catch(() => {
toast.error("The sandbox could not be set up for Claude. Check Settings > General > Sandbox.", { id: "claude-sandbox" });
});
};
const handleModelPick = (next: ModelRef, sessionId: string | null): boolean => {
const current = sessionId ? getSessionModelSelection(sessionId)?.model ?? null : null;
const pick = decideModelPick({ next, current, started: Boolean(sessionId && chatStarted(sessionId)), claude: useClaudeModels.getState(), switchable: modelModesRef.current.switchable });
if (pick.kind === "unavailable") toast(pick.message, { id: `claude-unavailable:${next.modelID}` });
else if (pick.kind === "new_chat" && current) setNewChatOffer({ next, current });
else if (pick.kind === "claude") setUpSandboxForClaude();
// A Claude pick in a fresh chat is a plain switch once the sandbox is on its way.
return pick.kind !== "switch" && pick.kind !== "same" && pick.kind !== "claude";
};
const modelPickRef = useRef(handleModelPick);
modelPickRef.current = handleModelPick;
useEffect(() => {
useModelPickGate.setState({ intercept: (next, sessionId) => modelPickRef.current(next, sessionId) });
return () => useModelPickGate.setState({ intercept: () => false });
}, []);
const confirmNewChat = async () => {
const offer = newChatOffer;
setNewChatOffer(null);
if (!offer || !selectedWorkspaceId) return;
if (isClaudeModel(offer.next)) setUpSandboxForClaude();
const sessionId = await handleCreateTaskInWorkspace(selectedWorkspaceId);
if (!sessionId) return;
useSessionModelStore.getState().setModel(sessionId, offer.next, null);
local.setPrefs((previous) => ({ ...previous, defaultModel: offer.next, modelVariant: null }));
};
const applySessionRouteModelSelection = useCallback((
next: ModelRef,
targetSessionId: string | null,
behavior?: { value: string | null },
) => {
const explicitBehavior = behavior !== undefined;
// One provider per chat (a started chat offers a new one for another provider), and Claude opens its own chat.
if (modelPickRef.current(next, targetSessionId)) return;
useModelCollectionsStore.getState().recordRecent(next);
if (targetSessionId) {
const sessionStore = useSessionModelStore.getState();
sessionStore.setModel(targetSessionId, next, explicitBehavior ? behavior.value : undefined);
if (explicitBehavior) sessionStore.setVariant(targetSessionId, behavior.value);
}
local.setPrefs((previous) => ({
...previous,
defaultModel: next,
modelVariant: explicitBehavior
? behavior.value
: previous.defaultModel?.providerID === next.providerID && previous.defaultModel.modelID === next.modelID
? previous.modelVariant
: null,
}));
focusPromptSoon();
}, [local]);
// Refresh the non-tab fields of the nav ref during render. The `options`
// field is maintained by the `onSessionTabsChange` callback from SessionPage.
sessionTabNavRef.current = {
options: sessionTabNavRef.current.options,
workspaceId: selectedWorkspaceId,
sessionId: selectedSessionId,
navigate: navigateToWorkspaceSession,
};
const paletteSessionGroups = useMemo<SessionGroupOption[]>(
() => selectedWorkspaceGroupState?.groups ?? [],
[selectedWorkspaceGroupState?.groups],
);
const currentSessionForGroupMove = useMemo(() => {
if (!selectedWorkspaceId || !selectedSessionId) return null;
return paletteSessionOptions.find(
(session) => session.workspaceId === selectedWorkspaceId && session.sessionId === selectedSessionId,
) ?? null;
}, [paletteSessionOptions, selectedSessionId, selectedWorkspaceId]);
const currentSessionActionPaletteItems = useMemo<PaletteItem[]>(() => {
if (!selectedSessionId || !selectedWorkspaceId || !currentSessionForGroupMove) return [];
const items: PaletteItem[] = [{
id: "session.pin.toggle",
title: currentSessionPinned
? t("session_management.unpin_session")
: t("session_management.pin_session"),
detail: currentSessionForGroupMove.title,
meta: "Session",
keywords: ["pin", "unpin", "favorite", "star", "keep on top", "sidebar"],
group: "actions",
action: () => {
setCommandPaletteOpen(false);
sessionManagementStore.getState().togglePin(selectedSessionId);
},
}];
if (opencodeClient) {
items.push({
id: "session.rename",
title: "Rename session…",
detail: currentSessionForGroupMove.title,
meta: "Session",
keywords: ["rename", "title", "name", "edit title"],
group: "actions",
action: () => {
setCommandPaletteOpen(false);
requestRenameSession(selectedSessionId);
},
});
}
return items;
}, [currentSessionForGroupMove, currentSessionPinned, opencodeClient, selectedSessionId, selectedWorkspaceId]);
const currentSessionGroupId = selectedSessionId
? selectedWorkspaceGroupState?.assignments[selectedSessionId] ?? null
: null;
const handleMoveCurrentSessionToGroup = useCallback((groupId: string) => {
if (!selectedWorkspaceId || !selectedSessionId) return;
assignSessionToGroup(selectedWorkspaceId, selectedSessionId, groupId);
}, [assignSessionToGroup, selectedSessionId, selectedWorkspaceId]);
const sessionSearchFetcher = useMemo<SessionMessageFetcher | null>(() => {
if (!client) return null;
// Cap the transcript fetch to keep multi-workspace scans fast; matches in
// anything older than the most recent 400 messages are traded away for
// responsiveness.
return async (workspaceId: string, sessionId: string) => {
const workspace = workspaces.find((item) => item.id === workspaceId);
const endpoint = endpointForWorkspace(workspace);
if (!endpoint) throw new Error("Workspace runtime is not connected.");
return getNativeSessionMessages(endpoint, sessionId, { limit: 400 });
};
}, [client, endpointForWorkspace, workspaces]);
// The start screen (no chat open): a quiet row of recent chats to continue and the chat search.
const homeView = useMemo<HomeViewContext>(() => ({
sessions: paletteSessionOptions,
workspaces: workspaces.map((workspace) => ({ id: workspace.id, name: workspace.displayNameResolved, task: Boolean(workspace.task) })),
onOpenSearch: () => setSessionSearchOpen(true),
onOpenSession: (workspaceId, sessionId) => {
setLegacySelectedWorkspaceId(workspaceId);
writeActiveWorkspaceId(workspaceId);
writeLastSessionFor(workspaceId, sessionId);
navigateToWorkspaceSession(workspaceId, sessionId);
},
}), [navigateToWorkspaceSession, paletteSessionOptions, setLegacySelectedWorkspaceId, setSessionSearchOpen, workspaces]);
const tasksPaletteItems = useMemo<PaletteItem[]>(() => tasksAvailable ? [{
id: "tasks.open",
title: "Open parallel tasks",
detail: tasksRunningCount ? `${tasksRunningCount} running` : "Tasks that run in their own copy of this repository",
meta: "Tasks",
searchText: "parallel tasks agents worktree board background",
action: () => {
setCommandPaletteOpen(false);
navigate(workspaceTasksRoute(tasksBoardWorkspaceId));
},
}, {
id: "tasks.new",
title: "New parallel task…",
detail: "Run a prompt in a separate copy of this repository",
meta: "Tasks",
searchText: "new parallel task agent worktree branch background",
action: () => {
setCommandPaletteOpen(false);
navigate(`${workspaceTasksRoute(tasksBoardWorkspaceId)}?new=1`);
},
}] : [], [navigate, tasksAvailable, tasksBoardWorkspaceId, tasksRunningCount]);
const sessionSearchPaletteItem = useMemo<PaletteItem>(() => ({
id: "session-search.open",
title: "Search session messages",
detail: "Deep search every session, including message content",
meta: "Cmd/Ctrl+Shift+F",
searchText: "search find sessions messages history transcript content",
action: () => {
setCommandPaletteOpen(false);
setSessionSearchOpen(true);
},
}), []);
const sessionFindPaletteItem = useMemo<PaletteItem | null>(() => {
if (!selectedSessionId) return null;
return {
id: "session-find.open",
title: "Find in conversation",
detail: "Search within the current conversation",
meta: "Cmd/Ctrl+F",
searchText: "find search current conversation session messages transcript",
action: () => {
setCommandPaletteOpen(false);
useSessionFindStore.getState().openFind({ sessionId: selectedSessionId });
},
};
}, [selectedSessionId]);
const editorLanguageFeatures = useEditorStore((state) => state.languageFeatures);
const layoutModeName = useEditorStore((state) => (selectedWorkspaceId ? state.modeByWorkspace[selectedWorkspaceId] : undefined) ?? "chat");
const layoutAvailable = isElectronRuntime() && Boolean(selectedWorkspace) && selectedWorkspace?.workspaceType !== "remote";
const layoutPaletteItems = useMemo<PaletteItem[]>(() => layoutAvailable ? [
{
id: "layout.toggle",
title: layoutModeName === "ide" ? "Switch to Chat layout" : "Switch to IDE layout",
detail: "Chat: sessions and the conversation. IDE: files, editor and terminal, with the chat on the right",
meta: "Cmd/Ctrl+Shift+Y",
searchText: "layout ide editor chat mode code files switch toggle",
action: () => {
setCommandPaletteOpen(false);
useEditorStore.getState().requestModeToggle();
},
},
...(layoutModeName === "ide" ? ([
["editor.search", "Search in files", "Find and replace across the project", "Cmd/Ctrl+Shift+F", "search"],
["editor.problems", "Show problems", "Errors and warnings from the language servers", "Cmd+Shift+M (macOS)", "problems"],
["editor.quick-open", "Go to file", "Open a project file by name", "Cmd/Ctrl+P", "quick-open"],
["editor.symbol", "Go to symbol in file", "Jump to a function, class or variable", "Cmd/Ctrl+Shift+O", "symbol"],
["editor.outline", "Show outline", "The active file's symbols, under Files", "", "outline"],
["editor.split", "Split editor", "Open the current file in a second editor group", "Cmd/Ctrl+\\", "split"],
["editor.preview", "Open Markdown preview to the side", "The current Markdown file, rendered in the other group", "Cmd/Ctrl+Shift+V", "preview-side"],
["editor.preview-here", "Open Markdown preview", "The current Markdown file, rendered in this group", "", "preview-here"],
["editor.focus-other-group", "Focus the other editor group", "Move the keyboard to the other side of a split editor", "", "focus-other-group"],
] as const).map(([id, title, detail, meta, command]) => ({
id,
title,
detail,
meta,
searchText: `editor ide ${title} ${detail}`.toLowerCase(),
action: () => {
setCommandPaletteOpen(false);
window.dispatchEvent(new CustomEvent("omnirush:editor-command", { detail: command }));
},
})) : []),
...(layoutModeName === "ide" ? [{
id: "editor.language-features",
title: editorLanguageFeatures ? "Turn off language features in the editor" : "Turn on language features in the editor",
detail: "Problems, hover, go to definition, rename and outline from the project's language servers",
meta: "",
searchText: "editor ide language features lsp problems hover rename outline server off on",
action: () => {
setCommandPaletteOpen(false);
useEditorStore.getState().setLanguageFeatures(!editorLanguageFeatures);
},
}, {
id: "layout.chat-panel",
title: "Show or hide the chat",
detail: "Fold the chat panel of the IDE layout away, or bring it back",
meta: "Cmd/Ctrl+Shift+H",
searchText: "chat panel hide show collapse ide",
action: () => {
setCommandPaletteOpen(false);
useEditorStore.getState().requestChatToggle();
},
}] : []),
] : [], [layoutAvailable, layoutModeName]);
const terminalPaletteItems = useMemo<PaletteItem[]>(() => platform.capabilities.terminal ? [
{
id: "terminal.toggle",
title: terminalOpen ? "Hide terminal" : "Show terminal",
detail: "Toggle the integrated terminal panel for this workspace",
meta: "Cmd/Ctrl+J",
searchText: "terminal shell command line console show hide toggle",
action: () => {
setCommandPaletteOpen(false);
setTerminalOpen((value) => !value);
},
},
] : [], [platform.capabilities.terminal, terminalOpen]);
const developerModePaletteItem = useMemo<PaletteItem>(() => ({
id: "developer-mode.toggle",
title: developerMode ? t("settings.disable_developer_mode") : t("settings.enable_developer_mode"),
detail: t("settings.developer_mode_desc"),
meta: developerMode ? "On" : "Off",
searchText: "developer dev mode debug diagnostics toggle enable disable",
action: () => {
setCommandPaletteOpen(false);
setDeveloperMode((current) => {
const next = !current;
try { window.localStorage.setItem("omnirush.developerMode", next ? "1" : "0"); } catch {}
return next;
});
},
}), [developerMode]);
// A focused side chat is the conversation people are looking at, so its ID is
// the one to copy and report. It only shows beside the route's own session.
const focusedSideChat = useWorkbenchStore((state) => (
state.focusedPane === "secondary"
&& state.primary?.workspaceId === selectedWorkspaceId
&& state.primary.sessionId === selectedSessionId
? state.secondary
: null
));
const focusedSession = useMemo(() => (
focusedSideChat ?? (selectedSessionId ? { workspaceId: selectedWorkspaceId, sessionId: selectedSessionId } : null)
), [focusedSideChat, selectedSessionId, selectedWorkspaceId]);
const buildCommandDiagnosticsBundle = useCallback(() => buildDiagnosticsBundleJson({
anyActiveRuns: activeReloadBlockingSessions.length > 0,
canReloadWorkspace: reloadCoordinator.canReloadWorkspaceEngine,
clientConnected: canCreateTask,
developerMode,
hostInfo: omnirushServerHostInfoState,
omnirushServerStatus: client ? "connected" : "disconnected",
omnirushServerUrl: baseUrl,
runtimeWorkspaceId: selectedWorkspaceEndpoint?.workspaceId ?? null,
focusedSession,
selectedWorkspaceId,
}), [
activeReloadBlockingSessions.length,
baseUrl,
canCreateTask,
client,
developerMode,
focusedSession,
omnirushServerHostInfoState,
reloadCoordinator.canReloadWorkspaceEngine,
selectedWorkspaceEndpoint?.workspaceId,
selectedWorkspaceId,
]);
const copySessionIdPaletteItem = useMemo(() => buildCopySessionIdPaletteItem(focusedSession?.sessionId, (sessionId) => {
setCommandPaletteOpen(false);
void copySessionId(sessionId);
}), [focusedSession?.sessionId]);
const diagnosticsCopyPaletteItem = useMemo<PaletteItem>(() => ({
id: "diagnostics.copy",
title: t("session.cmd_diagnostics_copy_title"),
detail: t("session.cmd_diagnostics_copy_detail"),
searchText: "logs share diagnostics debug support bundle troubleshoot copy report issue",
action: async () => {
setCommandPaletteOpen(false);
try {
const json = await buildCommandDiagnosticsBundle();
await navigator.clipboard.writeText(json);
toast.success(t("session.diagnostics_copied"));
} catch (error) {
toast.error(t("session.diagnostics_failed"), { description: describeRouteError(error) });
}
},
}), [buildCommandDiagnosticsBundle]);
const diagnosticsExportPaletteItem = useMemo<PaletteItem>(() => ({
id: "diagnostics.export",
title: t("session.cmd_diagnostics_export_title"),
detail: t("session.cmd_diagnostics_export_detail"),
searchText: "logs export diagnostics debug support bundle save file json download",
action: async () => {
setCommandPaletteOpen(false);
try {
const json = await buildCommandDiagnosticsBundle();
const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
downloadTextAsFile(`omnirush-diagnostics-${timestamp}.json`, json, "application/json");
toast.success(t("session.diagnostics_exported"));
} catch (error) {
toast.error(t("session.diagnostics_failed"), { description: describeRouteError(error) });
}
},
}), [buildCommandDiagnosticsBundle]);
const nextSessionTabPaletteItem = useMemo<PaletteItem>(() => ({
id: "session-tab.next",
title: "Next session tab",
detail: "Switch to the next session in this workspace",
meta: "Cmd/Ctrl+T",
searchText: "next session tab switch forward",
action: () => {
setCommandPaletteOpen(false);
goToNextSessionTab();
},
}), [goToNextSessionTab]);
const prevSessionTabPaletteItem = useMemo<PaletteItem>(() => ({
id: "session-tab.previous",
title: "Previous session tab",
detail: "Switch to the previous session in this workspace",
meta: "Cmd/Ctrl+Shift+T",
searchText: "previous session tab switch back",
action: () => {
setCommandPaletteOpen(false);
goToPrevSessionTab();
},
}), [goToPrevSessionTab]);
const reloadConfigPaletteItem = useMemo<PaletteItem>(() => ({
id: "reload-opencode-config",
title: t("session.cmd_reload_config_title"),
detail: t("session.cmd_reload_config_detail"),
meta: reloadCoordinator.canReloadWorkspaceEngine
? t("config.reload_engine")
: t("system.reload_unavailable"),
searchText: "reload opencode config providers models mcp jsonc refresh re-read engine restart",
action: () => {
setCommandPaletteOpen(false);
if (!reloadCoordinator.canReloadWorkspaceEngine) return;
void reloadCoordinator.reloadWorkspaceEngine();
},
}), [reloadCoordinator.canReloadWorkspaceEngine, reloadCoordinator.reloadWorkspaceEngine]);
const handleReorderWorkspaces = useCallback((workspaceIds: string[]) => {
const activeWorkspaceIds = new Set(workspacesRef.current.map((workspace) => workspace.id));
const nextOrderIds: string[] = [];
const nextOrderIdSet = new Set<string>();
for (const id of workspaceIds) {
if (!activeWorkspaceIds.has(id) || nextOrderIdSet.has(id)) continue;
nextOrderIds.push(id);
nextOrderIdSet.add(id);
}
for (const workspace of workspacesRef.current) {
if (nextOrderIdSet.has(workspace.id)) continue;
nextOrderIds.push(workspace.id);
nextOrderIdSet.add(workspace.id);
}
workspaceOrderIdsRef.current = nextOrderIds;
setWorkspaceOrderIds(nextOrderIds);
writeWorkspaceOrderIds(nextOrderIds);
setWorkspaces((current) => orderRouteWorkspaces(current, nextOrderIds));
}, []);
const handleArchiveSession = useCallback(
async (sessionId: string, archived: boolean) => {
if (!opencodeClient) return;
// The sidebar lists sessions from every workspace, so resolve the
// session's owning workspace instead of assuming the selected one —
// session.update needs the directory the session actually lives in.
const ownerWorkspace = workspaceSessionGroups.find((group) =>
group.sessions.some((session) => session?.id === sessionId),
)?.workspace;
const apply = async (nextArchived: boolean) => {
try {
await setSessionArchived(
opencodeClient,
sessionId,
nextArchived,
ownerWorkspace?.path || selectedWorkspaceRoot || undefined,
);
if (ownerWorkspace) await reloadWorkspaceSessions(ownerWorkspace.id);
await refreshRouteState();
return true;
} catch (error) {
console.error("[session-route] archive session failed", error);
toast.error(
nextArchived
? t("session_management.archive_failed")
: t("session_management.unarchive_failed"),
{ description: describeRouteError(error) },
);
return false;
}
};
if (!(await apply(archived))) return;
// Archiving is easy to hit by accident from the row's hover actions, so
// confirm it quietly with a way back. Undo reuses the same owner
// workspace and does not announce itself again.
toast.undo(
archived
? t("session_management.session_archived")
: t("session_management.session_unarchived"),
{
id: `session-archive:${sessionId}`,
icon: archived ? Archive : ArchiveRestore,
undo: { label: t("common.undo"), onClick: () => void apply(!archived) },
view: ownerWorkspace
? { label: t("common.view"), onClick: () => navigateToWorkspaceSession(ownerWorkspace.id, sessionId) }
: undefined,
closeLabel: t("common.close"),
},
);
},
[navigateToWorkspaceSession, opencodeClient, refreshRouteState, reloadWorkspaceSessions, selectedWorkspaceRoot, workspaceSessionGroups],
);
const handleCreateWorkspace = useCallback(async (
preset: WorkspacePreset,
folder: string | null,
options?: CreateWorkspaceOptions,
) => {
if (!folder) return;
const projectLabel = options?.projectLabel?.trim() ?? "";
setCreateWorkspaceBusy(true);
setCreateWorkspaceError(null);
try {
const workspaceName = folderNameFromPath(folder);
let list: WorkspaceList | null = null;
let createdOnServer = false;
if (client) {
list = await client
.createLocalWorkspace({ folderPath: folder, name: workspaceName, preset })
.then((serverList) => {
createdOnServer = true;
return serverList;
})
.catch(() => null);
}
if (!list) {
throw new Error("omnirush.ai server is unavailable. Start or reconnect the server before creating a workspace.");
}
const createdId = resolveWorkspaceListSelectedId(list) || list.workspaces[list.workspaces.length - 1]?.id || "";
let targetWorkspaceId = createdId;
let targetWorkspace = list.workspaces.find((workspace: WorkspaceInfo) => workspace.id === createdId) ?? null;
if (createdId) {
await workspaceSetSelected(createdId).catch(() => undefined);
await workspaceSetRuntimeActive(createdId).catch(() => undefined);
}
// First workspace on a fresh install: the omnirush.ai server was started
// engine-less (it only spawns OpenCode at boot when a workspace already
// exists), so sessions would hang forever. This boots the engine when
// it isn't running, same as the old /welcome flow did.
let sessionBaseUrl = baseUrl;
let sessionToken = token;
if (targetWorkspace && isDesktopRuntime()) {
await ensureDesktopLocalOmniRushConnection({
route: "session",
workspace: targetWorkspace,
allWorkspaces: list.workspaces,
}).catch(() => undefined);
// The engine boot can restart the server with fresh tokens; re-resolve
// so the first-session creation below doesn't use stale credentials.
const fresh = await resolveOmniRushConnection().catch(() => null);
if (fresh?.normalizedBaseUrl && fresh.resolvedToken) {
sessionBaseUrl = fresh.normalizedBaseUrl;
sessionToken = fresh.resolvedToken;
}
}
setCreateWorkspaceOpen(false);
// Mark onboarding complete so the /welcome redirect never fires again.
local.setPrefs((prev) => ({ ...prev, hasCompletedOnboarding: true }));
await refreshRouteState();
if (targetWorkspaceId) {
const workspacePath = targetWorkspace?.path?.trim() || folder;
const firstTaskPrompt = options?.firstTaskPrompt?.trim() ?? "";
const firstTaskAttachments = options?.firstTaskAttachments ?? [];
// A workspace registry mutation must not eagerly instantiate an
// OpenCode directory. Chat-first creation still needs a session for
// its supplied prompt; ordinary creation lands on the New task state.
const session = createdOnServer && sessionBaseUrl && sessionToken && (firstTaskPrompt || firstTaskAttachments.length > 0)
? await createClientV2(
`${(buildOmniRushWorkspaceBaseUrl(sessionBaseUrl, targetWorkspaceId) ?? sessionBaseUrl).replace(/\/+$/, "")}/opencode2`,
workspacePath || undefined,
{ token: sessionToken },
).session.create({ directory: workspacePath || undefined })
.then((result) => unwrap(result))
: null;
// A supplied prompt never just disappears: without its chat it goes back to the composer with this error.
if (!session && (firstTaskPrompt || firstTaskAttachments.length > 0)) {
throw new Error("The project was added but its chat could not be started yet. Send the message again.");
}
setLegacySelectedWorkspaceId(targetWorkspaceId);
writeActiveWorkspaceId(targetWorkspaceId);
if (projectLabel) {
writeWorkspaceProjectDimension(targetWorkspaceId, {
label: projectLabel,
});
}
captureAnalyticsEvent("workspace_created", { workspace_type: "local" });
noteNewBuildathonProject(workspacePath, targetWorkspace?.displayName ?? targetWorkspace?.name ?? null);
if (session?.id) {
captureAnalyticsEvent("task_created", { source: "workspace_created", workspace_type: "local" });
if (firstTaskPrompt || firstTaskAttachments.length) {
// Attachment chips only survive in-memory (File objects), so the
// persisted fallback draft drops their tokens.
saveSessionDraft(sessionDraftScope, targetWorkspaceId, session.id, { text: firstTaskPrompt.replace(/\[attachment [^\]]+\]/g, "").trim(), mode: "prompt" });
claimComposerSessionDraftScope(
session.id,
sessionDraftScopeKey(sessionDraftScope, targetWorkspaceId, session.id),
);
// The composer reads its draft from the composer state store, not
// the persisted draft store — seed both so the prompt shows up.
useComposerStateStore.getState().setDraft(session.id, firstTaskPrompt);
if (firstTaskAttachments.length) {
useComposerStateStore.getState().setAttachments(session.id, firstTaskAttachments);
}
// One-step run: the session surface sends the seeded draft itself.
markComposerAutoSend(session.id);
}
writeLastSessionFor(targetWorkspaceId, session.id);
rememberPendingCreatedSession(targetWorkspaceId, session.id);
setSessionsByWorkspaceId((current) => {
const next = {
...current,
[targetWorkspaceId]: mergeWorkspaceRouteSession(current[targetWorkspaceId] ?? [], session),
};
sessionsByWorkspaceIdRef.current = next;
return next;
});
}
navigateToWorkspaceSession(targetWorkspaceId, session?.id ?? null, { replace: true });
if (session?.id) focusPromptSoon();
}
} catch (error) {
setCreateWorkspaceError(describeWorkspaceCreateError(error));
if (options?.firstTaskPrompt || options?.firstTaskAttachments?.length) throw error;
} finally {
setCreateWorkspaceBusy(false);
}
}, [baseUrl, client, local, navigateToWorkspaceSession, refreshRouteState, rememberPendingCreatedSession, token]);
/**
* A parallel task: the server makes its worktree and workspace, then its
* chat is created there and the prompt sent the way the composer sends one
* (same model, agent and context), so it is captured like any chat.
*/
const startParallelTask = useCallback(async (workspaceId: string, prompt: string) => {
if (!client || !baseUrl || !token) throw new Error("omnirush.ai server is unavailable.");
// The board has no chat open: a task started there has no parent chat.
const created = await client.createWorkspaceTask(workspaceId, { prompt, parentSessionId: tasksRouteActive ? null : selectedSessionId });
const taskWorkspace = created.workspace;
await refreshRouteState();
void queryClient.invalidateQueries({ queryKey: workspaceTasksQueryKey(workspaceId) });
const opencodeUrl = `${(buildOmniRushWorkspaceBaseUrl(baseUrl, taskWorkspace.id) ?? baseUrl).replace(/\/+$/, "")}/opencode2`;
const engine = createClientV2(opencodeUrl, taskWorkspace.path || undefined, { token });
const session = unwrap(await engine.session.create({ directory: taskWorkspace.path || undefined }));
const system = await buildOmniRushSessionSystemContext(client, {
workspaceId: taskWorkspace.id,
cacheKey: session.id,
runtimeKey: environmentRuntimeKey,
});
const model = local.prefs.defaultModel;
const variant = resolveSendVariant(model, modelVariantValue);
const result = await engine.session.promptAsync({
sessionID: session.id,
parts: [{ type: "text", text: prompt }],
model: model ?? undefined,
agent: selectedAgent ?? undefined,
...(variant ? { variant } : {}),
system,
});
if (result.error) throw new Error(serializeSDKError(result.error));
if (model) useSessionModelStore.getState().setModel(session.id, model, variant);
writeLastSessionFor(taskWorkspace.id, session.id);
void queryClient.invalidateQueries({ queryKey: workspaceTasksQueryKey(workspaceId) });
return created.task;
}, [baseUrl, client, environmentRuntimeKey, local.prefs.defaultModel, modelVariantValue, queryClient, refreshRouteState, selectedAgent, selectedSessionId, tasksRouteActive, token]);
// The new task's folder, picked above its composer: switch to another
// workspace, or open a folder as a new one (the sidebar's "+" in one step).
const openProjectFolder = useCallback(async () => {
if (workspaces.length > 0 && checkDesktopRestriction({ restriction: "allowMultipleWorkspaces" })) {
restrictionNotice.show({
title: "Additional workspaces are restricted",
message: "Your organization administrator has restricted access to adding additional workspaces.",
});
return;
}
const folder = singlePickedDirectory(await pickDirectory({ title: t("onboarding.authorize_folder") }));
await handleCreateWorkspace("starter", folder);
}, [checkDesktopRestriction, handleCreateWorkspace, restrictionNotice, workspaces.length]);
// "Choose another folder" on a chat stopped because its folder is not writable (session-surface.tsx).
useEffect(() => {
if (!platform.capabilities.nativeFilePicker || !canCreateWorkspaces()) return;
const open = () => void openProjectFolder().catch(() => undefined);
window.addEventListener("omnirush-open-project-folder", open);
return () => window.removeEventListener("omnirush-open-project-folder", open);
}, [openProjectFolder, platform.capabilities.nativeFilePicker]);
// A Work chat has no project folder to pick; Code's picker never lists the Work workspace.
const newTaskComposerWithProjects = useMemo<NewTaskComposerContext | null>(() => newTaskComposerContext && (workChatActive ? newTaskComposerContext : {
...newTaskComposerContext,
projectPicker: {
workspaces: workspaces.filter((workspace) => shownInMode(workspace, workEnabled, "code")).map((workspace) => ({ id: workspace.id, name: workspace.displayNameResolved, path: workspace.path || null })),
selectedId: selectedWorkspaceId || null,
onSelect: (workspaceId: string) => {
setLegacySelectedWorkspaceId(workspaceId);
writeActiveWorkspaceId(workspaceId);
navigateToWorkspaceSession(workspaceId);
focusPromptSoon();
},
onOpenFolder: platform.capabilities.nativeFilePicker && canCreateWorkspaces() ? openProjectFolder : null,
},
}), [navigateToWorkspaceSession, newTaskComposerContext, openProjectFolder, platform.capabilities.nativeFilePicker, selectedWorkspaceId, setLegacySelectedWorkspaceId, workChatActive, workEnabled, workspaces]);
/**
* Chat-first onboarding: the empty-state composer creates a default chat
* workspace under the user's home folder instead of asking where to put
* it. Falls back to the create-workspace modal off desktop.
*/
const handleChatFirstTask = useCallback(async (prompt: string, attachments?: ComposerAttachment[]) => {
if (!isDesktopRuntime()) {
// The cloud workspace is provisioned by Den; boot takeover covers the pre-attach state.
if (!canCreateWorkspaces()) throw new Error("Workspace creation is unavailable.");
handleOpenCreateWorkspace();
throw new Error("Choose a workspace before sending this message.");
}
const home = await getDesktopHomeDir().catch(() => "");
if (!home) {
handleOpenCreateWorkspace();
throw new Error("Choose a workspace before sending this message.");
}
const folder = await joinDesktopPath(home, "omnirush.ai").catch(() => "");
if (!folder) {
handleOpenCreateWorkspace();
throw new Error("Choose a workspace before sending this message.");
}
await handleCreateWorkspace("starter", folder, { firstTaskPrompt: prompt, firstTaskAttachments: attachments ?? [] });
}, [handleCreateWorkspace, handleOpenCreateWorkspace]);
const createWorkspaceControlAction = useMemo<OmniRushControlAction>(() => ({
id: "workspace.create",
label: "Create a local workspace",
description: "Create a workspace at the given folder path without showing the file picker dialog, optionally labeling its project for analytics.",
sideEffect: "mutation",
requiresArgs: true,
args: [
{ name: "path", type: "string", required: true, description: "Absolute folder path for the new workspace." },
{ name: "projectLabel", type: "string", required: false, description: "Optional project name used to group the workspace's sessions in analytics." },
],
execute: async (args) => {
if (!canCreateWorkspaces()) return { ok: false, error: "workspace creation is unavailable" };
const parsed = args as { path?: string; projectLabel?: string } | undefined;
const folder = parsed?.path?.trim();
if (!folder) return { ok: false, error: "path is required" };
const trimmedLabel = parsed?.projectLabel?.trim() ?? "";
await handleCreateWorkspace("starter", folder, trimmedLabel ? { projectLabel: trimmedLabel } : undefined);
return { path: folder };
},
}), [handleCreateWorkspace]);
useControlAction(createWorkspaceControlAction);
// Sessions created outside this window (server-side session.create, other
// clients) never reach a non-selected workspace's cached list, so callers
// that create them ask the sidebar to refetch that one workspace.
const reloadWorkspaceSessionsControlAction = useMemo<OmniRushControlAction>(() => ({
id: "workspace.reload_sessions",
label: "Reload a workspace's sessions",
description: "Refetch the session list of one workspace so sessions created outside this window appear in the sidebar.",
sideEffect: "mutation",
requiresArgs: true,
args: [
{ name: "workspaceId", type: "string", required: true, description: "Workspace id whose session list should be refetched." },
],
execute: async (args) => {
const candidate = typeof args === "object" && args !== null && "workspaceId" in args ? args.workspaceId : undefined;
const workspaceId = typeof candidate === "string" ? candidate.trim() : "";
if (!workspaceId) return { ok: false, error: "workspaceId is required" };
if (!workspaces.some((workspace) => workspace.id === workspaceId)) {
return { ok: false, error: `No workspace matched ${workspaceId}` };
}
await reloadWorkspaceSessions(workspaceId);
return { workspaceId };
},
}), [reloadWorkspaceSessions, workspaces]);
useControlAction(reloadWorkspaceSessionsControlAction);
const handleCreateRemoteWorkspace = useCallback(async (input: {
omnirushHostUrl?: string | null;
omnirushToken?: string | null;
directory?: string | null;
displayName?: string | null;
}) => {
const baseUrlValue = input.omnirushHostUrl?.trim() ?? "";
if (!baseUrlValue) return false;
setCreateWorkspaceRemoteBusy(true);
setCreateWorkspaceRemoteError(null);
try {
const remoteType: "omnirush" = "omnirush";
const payload = {
baseUrl: baseUrlValue,
omnirushHostUrl: baseUrlValue,
omnirushToken: input.omnirushToken?.trim() || null,
displayName: input.displayName?.trim() || null,
directory: input.directory?.trim() || null,
remoteType,
};
let list: WorkspaceList | null = null;
if (isDesktopRuntime()) {
list = await workspaceCreateRemote(payload);
} else if (client) {
list = await client.createRemoteWorkspace(payload).catch(() => null);
}
if (!list) {
throw new Error("omnirush.ai server is unavailable. Start or reconnect the server before connecting a remote workspace.");
}
const createdId = resolveWorkspaceListSelectedId(list) || list.workspaces[list.workspaces.length - 1]?.id || "";
if (createdId) {
await workspaceSetSelected(createdId).catch(() => undefined);
await workspaceSetRuntimeActive(createdId).catch(() => undefined);
}
setCreateWorkspaceOpen(false);
// Mark onboarding complete so the /welcome redirect never fires again.
local.setPrefs((prev) => ({ ...prev, hasCompletedOnboarding: true }));
await refreshRouteState();
return true;
} catch (error) {
setCreateWorkspaceRemoteError(error instanceof Error ? error.message : t("app.unknown_error"));
return false;
} finally {
setCreateWorkspaceRemoteBusy(false);
}
}, [client, local, refreshRouteState]);
const startWorkChat = async (prompt: string) => {
const workspaceId = workWorkspace?.id;
if (!workspaceId) throw new Error("Work is still getting ready. Try again in a moment.");
const sessionId = await handleCreateTaskInWorkspaceWithOpenMode(workspaceId, "primary");
if (!sessionId) throw new Error("Could not start a chat. Try again in a moment.");
saveSessionDraft(sessionDraftScope, workspaceId, sessionId, { text: prompt, mode: "prompt" });
useComposerStateStore.getState().setDraft(sessionId, prompt);
markComposerAutoSend(sessionId);
};
const startAppConversation = async (prompt: string) => {
const sessionId = await handleCreateTaskInWorkspaceWithOpenMode(selectedWorkspaceId, "primary");
if (!sessionId) throw new Error("Could not start a conversation. Check that your workspace is connected.");
saveSessionDraft(sessionDraftScope, selectedWorkspaceId, sessionId, { text: prompt, mode: "prompt" });
focusPromptSoon();
};
return (
<WorkspaceProvider
client={opencodeClient}
opencodeBaseUrl={opencodeBaseUrl}
omnirushServerClient={selectedWorkspaceEndpoint?.client ?? null}
workspaceId={selectedWorkspaceEndpoint?.workspaceId ?? ""}
selectedWorkspaceRoot={selectedWorkspaceRoot}
>
{opencodeClient && selectedWorkspaceEndpoint && opencodeBaseUrl && selectedWorkspaceServerToken ? (
<ReactSessionRuntime
// Use the server-side workspace id (the one without the `rem_`
// prefix) so the React Query cache keys session-sync writes match
// the keys SessionSurface reads from. Otherwise events arrive but
// the UI never sees them and gets stuck on "thinking".
workspaceId={selectedWorkspaceEndpoint.workspaceId}
sessionId={selectedSessionId}
activeSessionIds={activeSelectedWorkspaceSessionIds}
opencodeBaseUrl={opencodeBaseUrl}
omnirushToken={selectedWorkspaceServerToken}
onSessionCreated={handleRuntimeSessionCreated}
onSessionUpdated={handleRuntimeSessionUpdated}
onSessionDeleted={handleRuntimeSessionDeleted}
/>
) : null}
<SessionPage
sessionNumberShortcuts={sessionNumberShortcuts}
selectedSessionId={selectedSessionId}
selectedWorkspaceId={selectedWorkspaceId}
selectedWorkspaceDisplay={selectedWorkspace ? {
id: selectedWorkspace.id,
name: selectedWorkspace.name ?? undefined,
displayName: selectedWorkspace.displayNameResolved,
workspaceType: selectedWorkspace.workspaceType,
} : { workspaceType: "local" }}
selectedWorkspaceRoot={selectedWorkspaceRoot}
selectedWorkspaceError={selectedWorkspaceError}
runtimeWorkspaceId={selectedWorkspaceEndpoint?.workspaceId || null}
opencodeBaseUrl={opencodeBaseUrl}
workspaces={workspaces}
clientConnected={canCreateTask}
omnirushServerStatus={client ? "connected" : "disconnected"}
omnirushServerClient={selectedWorkspaceEndpoint?.client ?? client}
environmentClient={client}
omnirushServerToken={selectedWorkspaceServerToken}
developerMode={developerMode}
headerStatus={
canCreateTask || (activeComposerTargetsSession && !selectedWorkspaceError && activeComposerAvailability.status === "available")
? t("status.connected")
: (modelUnavailableMessage ?? t("session.loading_detail"))
}
busyHint={organizationModelsEmpty ? t("models.organization_models_empty") : effectiveLoading ? t("session.loading_detail") : null}
startupPhase={effectiveLoading ? "nativeInit" : "ready"}
providerConnectedIds={providerConnectedIds}
hasUsableModel={hasUsableModel}
providers={providers}
mcpConnectedCount={mcpConnectedCount}
onSendFeedback={() => {
// The desktop sends it to the OmniRush team (in-app); elsewhere the public issue form.
if (isDesktopRuntime()) {
openFeedbackDialog({ trigger: "menu", sessionId: selectedSessionId ?? null });
return;
}
platform.openLink(
buildFeedbackUrl({
entrypoint: "status-bar",
}),
);
}}
onOpenSettings={() => handleOpenSettings("/settings/general")}
onOpenExtensions={() => handleOpenExtensions()}
onOpenProviderAuth={handleOpenProviderAuth}
onChatFirstTask={handleChatFirstTask}
chatFirstBusy={createWorkspaceBusy}
newTaskComposer={newTaskComposerWithProjects}
home={homeView}
providerAuthModal={sessionProviderAuthSnapshot.providerAuthModalOpen ? {
open: true,
loading: false,
submitting: sessionProviderAuthSnapshot.providerAuthBusy,
error: sessionProviderAuthSnapshot.providerAuthError,
preferredProviderId: sessionProviderAuthSnapshot.providerAuthPreferredProviderId,
workerType: sessionProviderAuthSnapshot.providerAuthWorkerType,
providers: sessionProviderAuthSnapshot.providerAuthProviders.filter(
(provider) => !isDesktopProviderBlocked({ providerId: provider.id, checkRestriction: checkDesktopRestriction }),
),
connectedProviderIds: providerConnectedIds,
authMethods: Object.fromEntries(
Object.entries(sessionProviderAuthSnapshot.providerAuthMethods).filter(
([providerId]) => !isDesktopProviderBlocked({ providerId, checkRestriction: checkDesktopRestriction }),
),
),
onSelect: sessionProviderAuthStore.startProviderAuth,
onSubmitApiKey: async (providerId, apiKey) => {
const result = await sessionProviderAuthStore.submitProviderApiKey(providerId, apiKey);
modelPicker.setRecentProviderIds(new Set([providerId]));
modelPicker.setQuery("");
modelPicker.setOpen(true);
return result;
},
onSubmitOAuth: sessionProviderAuthStore.completeProviderAuthOAuth,
onRefreshProviders: sessionProviderAuthStore.refreshProviders,
onClose: () => sessionProviderAuthStore.closeProviderAuthModal(),
} : null}
settingsSlot={
<SettingsSurface
embedded
initialPath="extensions"
workspaceId={selectedWorkspaceId}
onClose={() => {
try {
window.dispatchEvent(new CustomEvent("omnirush-close-right-pane"));
} catch {
// ignore
}
}}
/>
}
primaryTitle={workRouteActive ? (location.pathname.startsWith(WORK_CONNECTORS_ROUTE) ? "Connectors" : location.pathname.startsWith(WORK_KNOWLEDGE_ROUTE) ? "Knowledge" : "Work") : appsRouteActive ? "Dashboard" : automationsRouteActive ? "Automations" : dashboardRouteActive ? "Dashboard" : tasksRouteActive ? "Parallel tasks" : undefined}
workChat={workChatActive}
primarySlot={workRouteActive ? (
location.pathname.startsWith(WORK_CONNECTORS_ROUTE) ? (
<WorkConnectorsPage client={client ?? null} openLink={(url) => platform.openLink(url)} onBack={() => navigate(WORK_HOME_ROUTE)} />
) : location.pathname.startsWith(WORK_KNOWLEDGE_ROUTE) ? (
<WorkKnowledgePage client={client ?? null} openLink={(url) => platform.openLink(url)} onAsk={startWorkChat} onBack={() => navigate(WORK_HOME_ROUTE)} />
) : (
<WorkHome
busy={!workWorkspace}
message={workState.data?.message ?? null}
onStart={startWorkChat}
onOpenConnectors={() => navigate(WORK_CONNECTORS_ROUTE)}
/>
)
) : tasksRouteActive && tasksAvailable ? (
<TasksBoardPage
client={client}
workspaceId={tasksBoardWorkspaceId}
workspaceName={workspaces.find((workspace) => workspace.id === tasksBoardWorkspaceId)?.displayNameResolved ?? ""}
onStartTask={(prompt) => startParallelTask(tasksBoardWorkspaceId, prompt)}
onOpenChat={(workspaceId, sessionId) => {
setLegacySelectedWorkspaceId(workspaceId);
writeActiveWorkspaceId(workspaceId);
if (sessionId) writeLastSessionFor(workspaceId, sessionId);
navigateToWorkspaceSession(workspaceId, sessionId);
}}
onWorkspacesChanged={() => void refreshRouteState()}
/>
) : tasksRouteActive && selectedWorkspace?.workspaceType === "remote" ? (
<div className="mx-auto max-w-xl p-6 pt-16 text-center" data-testid="tasks-remote">
<h2 className="text-base font-medium">Parallel tasks run on this computer</h2>
<p className="mt-2 text-sm text-muted-foreground">
This workspace is on a remote worker. Open a project folder on this computer to start tasks in their own copies of it.
</p>
</div>
) : appsRouteActive ? (
<AppsPage onNewApp={startAppConversation} />
) : automationsRouteActive ? (
<AutomationsPage providerCatalog={providerCatalog} workspaceId={selectedWorkspaceId} />
) : dashboardRouteActive ? (
<WorkspaceProvider
client={opencodeClient}
opencodeBaseUrl={opencodeBaseUrl}
omnirushServerClient={dashboardEndpoint?.client ?? null}
workspaceId={dashboardEndpoint?.workspaceId ?? ""}
selectedWorkspaceRoot={selectedWorkspaceRoot}
>
<DashboardPage fallbackEndpoints={dashboardFallbackEndpoints} onCreateApp={startAppConversation} />
</WorkspaceProvider>
) : undefined}
terminalOpen={terminalOpen && !workChatActive}
onTerminalOpenChange={setTerminalOpen}
opencodeClient={opencodeClient}
onSessionTabsChange={(tabs) => {
sessionTabNavRef.current = { ...sessionTabNavRef.current, options: tabs };
}}
sidebar={{
workspaceSessionGroups: sidebarWorkspaceSessionGroups,
modeToggle: workEnabled ? <WorkModeToggle mode={appMode} onChange={switchAppMode} shortcut={/Mac/i.test(typeof navigator === "undefined" ? "" : navigator.platform) ? "⌘⇧K" : "Ctrl+Shift+K"} /> : undefined,
workNavigation: appMode === "work" ? { onOpenHome: () => navigate(WORK_HOME_ROUTE), onOpenConnectors: () => navigate(WORK_CONNECTORS_ROUTE), connectorsActive: location.pathname.startsWith(WORK_CONNECTORS_ROUTE), onOpenKnowledge: () => navigate(WORK_KNOWLEDGE_ROUTE), knowledgeActive: location.pathname.startsWith(WORK_KNOWLEDGE_ROUTE) } : undefined,
selectedWorkspaceId,
selectedSessionId,
developerMode: false,
sessionStatusById: sidebarSessionStatusById,
connectingWorkspaceId: null,
workspaceConnectionStateById,
newTaskDisabled: !canCreateTask,
sidebarHydratedFromCache: Object.values(sessionsByWorkspaceId).some((list) => list.length > 0),
startupPhase: effectiveLoading ? "nativeInit" : "ready",
automationsActive: automationsRouteActive,
automationsNeedAttention,
onOpenAutomations: automationsNavigationAvailable
? () => {
navigate(automationsRoute());
}
: undefined,
dashboardActive: dashboardRouteActive || appsRouteActive,
tasksActive: tasksRouteActive,
tasksRunningCount,
onOpenTasksForWorkspace: (workspaceId: string) => navigate(workspaceTasksRoute(workspaceId)),
onOpenTasks: tasksAvailable ? () => navigate(workspaceTasksRoute(tasksBoardWorkspaceId)) : undefined,
onOpenDashboard: mcpAppsDashboardEnabled
? () => {
navigate(dashboardRoute());
}
: undefined,
onSelectWorkspace: async (workspaceId) => {
if (workspaceId === selectedWorkspaceId) return true;
setLegacySelectedWorkspaceId(workspaceId);
writeActiveWorkspaceId(workspaceId || null);
// Route adoption owns desktop persistence and server activation.
// Centralizing those effects lets rapid navigation coalesce to the
// last route instead of racing stale IPC and engine reloads.
// If we remember what the user last opened here and that session
// still exists in our local list, navigate. Otherwise stay put.
const remembered = readLastSessionFor(workspaceId);
if (remembered && remembered !== selectedSessionId) {
const known = sessionsByWorkspaceId[workspaceId];
if (known?.some((session) => session?.id === remembered)) {
navigateToWorkspaceSession(workspaceId, remembered);
} else {
navigateToWorkspaceSession(workspaceId);
}
} else {
navigateToWorkspaceSession(workspaceId);
}
return true;
},
onOpenSession: (workspaceId, sessionId) => {
setLegacySelectedWorkspaceId(workspaceId);
writeActiveWorkspaceId(workspaceId || null);
writeLastSessionFor(workspaceId, sessionId);
navigateToWorkspaceSession(workspaceId, sessionId);
},
onPrefetchSession: () => {},
onCreateTaskInWorkspace: (workspaceId, groupId) => {
// A new Work chat starts from the Work home (templates); Code is unchanged.
if (appMode === "work") {
navigate(WORK_HOME_ROUTE);
return;
}
const { focusedPane, secondary } = useWorkbenchStore.getState();
const hasWorkspaceError = Boolean(errorsByWorkspaceId[workspaceId]?.trim())
|| workspaceConnectionStateById[workspaceId]?.status === "error";
if (!groupId && !hasWorkspaceError && !(focusedPane === "secondary" && secondary)) {
// The empty composer creates its session on submit. Opening it must
// not wait for an engine request, especially on a cold v2 runtime.
setLegacySelectedWorkspaceId(workspaceId);
writeActiveWorkspaceId(workspaceId);
navigateToWorkspaceSession(workspaceId);
focusPromptSoon();
return;
}
void handleCreateTaskInWorkspace(workspaceId).then((sessionId) => {
if (sessionId && groupId) {
sessionManagementStore.getState().assignGroup(workspaceId, sessionId, groupId);
}
});
},
onCreateSplitTaskInWorkspace: (workspaceId) => {
void handleCreateSplitTaskInWorkspace(workspaceId);
},
onCreateTaskWithPrompt: async (
workspaceId,
prompt,
attachments,
handoff?: NewTaskComposerHandoff,
) => {
const navigationOwner = {
...selectedConversationRef.current,
paneOwner: focusedWorkbenchPaneOwner(),
};
const workspace = workspaces.find((item) => item.id === workspaceId);
if (!workspace) throw new Error("Workspace is unavailable. Try again.");
const endpoint = endpointForWorkspace(workspace);
if (!endpoint?.token) throw new Error("Workspace is disconnected. Reconnect and try again.");
const session = await createRouteSession(endpoint, workspace.path?.trim() || undefined);
const continuation = handoff
? snapshotComposerSessionState(handoff.getContinuation())
: null;
if (workspaceId === selectedWorkspaceId) {
void refreshCloudProviderSync("new_chat");
}
const firstTaskPrompt = prompt.trim();
if (firstTaskPrompt || attachments?.length) {
const firstTaskAttachments = attachments ?? [];
const destinationScopeKey = sessionDraftScopeKey(sessionDraftScope, workspaceId, session.id);
if (handoff && continuation) {
// The source composer remains live while session creation is in
// flight. Seed its latest continuation in the destination, but
// send the immutable submitted snapshot through the scoped mark.
saveSessionDraft(sessionDraftScope, workspaceId, session.id, {
text: persistableComposerDraftText(continuation.draft, continuation.pasteParts),
mode: "prompt",
});
claimComposerSessionDraftScope(session.id, destinationScopeKey);
useComposerStateStore.setState((state) => ({
sessions: {
...state.sessions,
[session.id]: continuation,
},
}));
markComposerAutoSend(session.id, {
scopeKey: composerAutoSendScopeKey({
draftScope: sessionDraftScope,
opencodeBaseUrl: endpoint.opencodeBaseUrl,
workspaceId,
sessionId: session.id,
}),
composer: handoff.submitted,
});
} else {
// Attachment chips only survive in-memory (File objects), so the
// persisted fallback draft drops their tokens.
saveSessionDraft(sessionDraftScope, workspaceId, session.id, { text: firstTaskPrompt.replace(/\[attachment [^\]]+\]/g, "").trim(), mode: "prompt" });
claimComposerSessionDraftScope(session.id, destinationScopeKey);
// The composer reads its draft from the composer state store,
// not the persisted draft store — seed both.
useComposerStateStore.getState().setDraft(session.id, firstTaskPrompt);
if (firstTaskAttachments.length) {
useComposerStateStore.getState().setAttachments(session.id, firstTaskAttachments);
}
// Legacy callers still seed the submitted draft directly.
markComposerAutoSend(session.id);
}
}
rememberPendingCreatedSession(workspaceId, session.id);
applyLastUsedModelToSession(session.id, workspaceId);
setSessionsByWorkspaceId((current) => ({
...current,
[workspaceId]: mergeWorkspaceRouteSession(current[workspaceId] ?? [], session),
}));
const stillOwnsNavigation = navigationOwner.workspaceId === workspaceId
&& selectedConversationRef.current.workspaceId === navigationOwner.workspaceId
&& selectedConversationRef.current.sessionId === navigationOwner.sessionId
&& selectedConversationRef.current.draftScope === navigationOwner.draftScope
&& selectedConversationRef.current.location === navigationOwner.location
&& selectedConversationRef.current.locationKey === navigationOwner.locationKey
&& selectedConversationRef.current.navigationGeneration === navigationOwner.navigationGeneration
&& focusedWorkbenchPaneOwner() === navigationOwner.paneOwner;
if (stillOwnsNavigation) {
writeActiveWorkspaceId(workspaceId || null);
writeLastSessionFor(workspaceId, session.id);
navigateToWorkspaceSession(workspaceId, session.id);
focusPromptSoon();
}
},
onOpenRenameWorkspace: handleOpenRenameWorkspace,
onShareWorkspace: handleShareWorkspace,
onRevealWorkspace: (id) => void handleRevealWorkspace(id),
onRecoverWorkspace: (workspaceId) => runRemoteWorkspaceConnectionCheck(workspaceId, "recover"),
onTestWorkspaceConnection: (workspaceId) => runRemoteWorkspaceConnectionCheck(workspaceId, "test"),
onRetryWorkspaceTasks: retryWorkspaceSessions,
onEditWorkspaceConnection: remoteWorkspaceConnectionEditor.open,
onForgetWorkspace: (id) => void handleForgetWorkspace(id),
onOpenCreateWorkspace: handleOpenCreateWorkspace,
onOpenSessionSearch: () => setSessionSearchOpen(true),
onReorderWorkspaces: handleReorderWorkspaces,
}}
surface={surfaceProps}
resolvePaneRuntime={resolvePaneRuntime}
history={{
canUndo: false,
canRedo: false,
busyAction: null,
onUndo: () => {},
onRedo: () => {},
}}
todos={todos}
sessionLoadingById={(sessionId) => effectiveLoading && Boolean(sessionId && sessionId === selectedSessionId)}
shareWorkspaceModal={
shareWorkspaceState.shareWorkspaceOpen
? {
open: true,
onClose: shareWorkspaceState.closeShareWorkspace,
workspaceName: shareWorkspaceState.shareWorkspaceName,
workspaceDetail: shareWorkspaceState.shareWorkspaceDetail,
fields: shareWorkspaceState.shareFields,
remoteAccess:
isDesktopRuntime() && shareWorkspaceState.shareWorkspace?.workspaceType === "local"
? {
enabled: omnirushServerSettings.remoteAccessEnabled === true,
busy: remoteAccessRestart.busy,
error: remoteAccessRestart.error,
status: remoteAccessRestart.status,
onSave: handleSaveShareRemoteAccess,
}
: undefined,
note: shareWorkspaceState.shareNote,
onExportConfig:
shareWorkspaceState.exportDisabledReason === null
? () => {
const id = shareWorkspaceState.shareWorkspaceId;
if (!id) return;
void handleExportWorkspaceConfig(id);
}
: undefined,
exportDisabledReason: shareWorkspaceState.exportDisabledReason,
}
: null
}
activePermission={activePermission}
activePermissionSourceTitle={activePermissionSourceTitle}
permissionReplyBusy={permissionReplyBusy}
respondPermission={respondPermission}
activeQuestion={activeQuestion}
questionReplyBusy={questionReplyBusy}
respondQuestion={respondQuestion}
safeStringify={safeStringify}
onRenameSession={
opencodeClient
? async (sessionId, nextTitle) => {
const trimmed = nextTitle.trim();
if (!trimmed) return;
await opencodeClient.session.update({
sessionID: sessionId,
title: trimmed,
directory: selectedWorkspaceRoot || undefined,
});
await refreshRouteState();
}
: undefined
}
onDeleteSession={
client && selectedWorkspaceId
? async (sessionId) => {
// The sidebar lists sessions from every workspace: delete through
// the workspace that owns the session, whose engine runs it and
// whose list shows it.
const ownerId = workspaceSessionGroups.find((group) =>
group.sessions.some((session) => session?.id === sessionId),
)?.workspace.id;
const ownerWorkspace = workspaces.find((workspace) => workspace.id === ownerId) ?? selectedWorkspace;
const endpoint = endpointForWorkspace(ownerWorkspace);
if (!ownerWorkspace || !endpoint) throw new Error(t("session.delete_unavailable"));
await deleteRouteSession(endpoint, sessionId);
forgetDeletedSession(sessionId);
if (selectedSessionId === sessionId) {
navigateToWorkspaceSession(selectedWorkspaceId);
}
void reloadWorkspaceSessions(ownerWorkspace.id);
}
: undefined
}
onArchiveSession={opencodeClient ? handleArchiveSession : undefined}
archiveDisabledReason={archiveDisabledReason}
statusBar={{
// No per-session loading state here: the account row renders only
// app-scoped facts. Session loading lives in the pane; an unresolved
// model surfaces in the composer where the person can act on it.
reloadBusy: reloadCoordinator.reloadBusy,
reloadError: reloadCoordinator.reloadError,
omniRushConnectState: sessionMcpMaintenance,
}}
notFoundMessage={gatedRouteNotFoundMessage}
mainContentTakeover={
extensionsMainOpen ? (
<SettingsSurface
standaloneExtensions
workspaceId={selectedWorkspaceId || undefined}
/>
) : cloudWorkspaceMainContentTakeover
}
mainContentTitle={extensionsMainOpen ? t("settings.tab_extensions") : undefined}
extensionsActive={extensionsMainOpen}
onAccessibleTargetsChange={setPaletteAccessibleTargets}
/>
<ConfirmModal
open={newChatOffer !== null}
title={newChatOffer ? newChatPrompt(modelTitle(newChatOffer.current), modelTitle(newChatOffer.next)).title : ""}
message={newChatOffer ? newChatPrompt(modelTitle(newChatOffer.current), modelTitle(newChatOffer.next)).message : ""}
confirmLabel="Start new chat"
cancelLabel="Keep this chat"
onConfirm={() => void confirmNewChat()}
onCancel={() => setNewChatOffer(null)}
/>
<CreateWorkspaceModal
open={createWorkspaceOpen}
onClose={() => {
setCreateWorkspaceOpen(false);
setCreateWorkspaceError(null);
}}
onConfirm={handleCreateWorkspace}
onConfirmRemote={handleCreateRemoteWorkspace}
onPickFolder={async () => singlePickedDirectory(await pickDirectory({ title: t("onboarding.authorize_folder") }))}
submitting={createWorkspaceBusy}
localError={createWorkspaceError}
localDisabled={!platform.capabilities.nativeFilePicker}
localDisabledReason={
platform.capabilities.nativeFilePicker
? undefined
: t("app.local_disabled_reason")
}
remoteSubmitting={createWorkspaceRemoteBusy}
remoteError={createWorkspaceRemoteError}
/>
<CreateRemoteWorkspaceModal
open={remoteWorkspaceConnectionEditor.workspace !== null}
onClose={remoteWorkspaceConnectionEditor.close}
onConfirm={(input) => void remoteWorkspaceConnectionEditor.save(input)}
initialValues={remoteWorkspaceConnectionEditor.initialValues}
submitting={remoteWorkspaceConnectionEditor.busy}
error={remoteWorkspaceConnectionEditor.error}
title={t("dashboard.edit_remote_workspace_title")}
subtitle={t("dashboard.edit_remote_workspace_subtitle")}
confirmLabel={t("dashboard.edit_remote_workspace_confirm")}
/>
<RenameWorkspaceModal
open={renameWorkspaceId !== null}
title={renameWorkspaceTitle}
busy={renameWorkspaceBusy}
canSave={!renameWorkspaceBusy && renameWorkspaceTitle.trim().length > 0}
onClose={() => {
if (renameWorkspaceBusy) return;
setRenameWorkspaceId(null);
setRenameWorkspaceTitle("");
}}
onSave={() => void handleSaveRenameWorkspace()}
onTitleChange={setRenameWorkspaceTitle}
/>
<CommandPalette
open={commandPaletteOpen}
onClose={() => setCommandPaletteOpen(false)}
developerMode={developerMode}
onCreateNewSession={() => {
if (selectedWorkspaceId) {
void handleCreateTaskInWorkspace(selectedWorkspaceId);
}
}}
onCreateNewSplitSession={() => {
if (selectedWorkspaceId) {
void handleCreateSplitTaskInWorkspace(selectedWorkspaceId);
}
}}
onOpenSession={(workspaceId, sessionId) => navigateToWorkspaceSession(workspaceId, sessionId)}
currentSession={selectedSessionId ? { workspaceId: selectedWorkspaceId, sessionId: selectedSessionId } : null}
onOpenSessionInSplit={(workspaceId, sessionId) => {
const option = paletteSessionOptions.find((candidate) => (
candidate.workspaceId === workspaceId && candidate.sessionId === sessionId
));
const tab = {
workspaceId,
sessionId,
title: option?.title,
workspaceTitle: option?.workspaceTitle ?? workspaceId,
};
const workbench = useWorkbenchStore.getState();
workbench.openTab(tab);
workbench.setSplit(tab);
}}
onOpenSettings={(route) => handleOpenSettings(route ?? "/settings/general")}
onOpenExtensions={(section) => handleOpenExtensions(section)}
onToggleSidebar={toggleSidebar}
onOpenAutomations={() => navigate(automationsRoute())}
onOpenDashboard={() => navigate(dashboardRoute())}
onCreateWorkspace={handleOpenCreateWorkspace}
modelOptions={pickerOptions}
selectedModel={paletteSelectedModel}
selectedModelBehavior={paletteSelectedModelBehavior}
onSelectModel={(next, behavior) => {
applySessionRouteModelSelection(next, selectedSessionId || null, { value: behavior });
}}
selectedModelLabel={modelLabel}
accessibleTargets={paletteAccessibleTargets}
onOpenAccessibleTarget={(target) => {
try {
window.dispatchEvent(new CustomEvent("omnirush-open-accessible-target", { detail: target }));
} catch {
// ignore event dispatch failures
}
}}
onHideAccessibleTarget={(target) => {
try {
window.dispatchEvent(new CustomEvent("omnirush-hide-accessible-target", { detail: target }));
} catch {
// ignore event dispatch failures
}
}}
sessions={paletteSessionOptions}
sessionGroups={paletteSessionGroups}
currentSessionForGroupMove={currentSessionForGroupMove}
currentSessionGroupId={currentSessionGroupId}
onMoveCurrentSessionToGroup={handleMoveCurrentSessionToGroup}
extraItems={[...currentSessionActionPaletteItems, ...(sessionFindPaletteItem ? [sessionFindPaletteItem] : []), sessionSearchPaletteItem, ...tasksPaletteItems, ...layoutPaletteItems, ...terminalPaletteItems, ...(checkDesktopRestriction({ restriction: "allowControlSettings" }) ? [] : [developerModePaletteItem]), ...(copySessionIdPaletteItem ? [copySessionIdPaletteItem] : []), diagnosticsCopyPaletteItem, diagnosticsExportPaletteItem, nextSessionTabPaletteItem, prevSessionTabPaletteItem, reloadConfigPaletteItem]}
listAgents={listAgents}
selectedAgent={selectedAgent}
onSelectAgent={setSelectedAgent}
/>
<SessionSearchDialog
open={sessionSearchOpen}
onClose={() => setSessionSearchOpen(false)}
sessions={paletteSessionOptions}
fetchMessages={sessionSearchFetcher}
onOpenSession={(workspaceId, sessionId) => navigateToWorkspaceSession(workspaceId, sessionId)}
/>
<ModelPickerModal
open={modelPicker.open}
options={pickerOptions}
organizationModelsEmpty={organizationModelsEmpty}
organizationModelsSettingsUrl={organizationModelsSettingsUrl}
query={modelPicker.query}
setQuery={modelPicker.setQuery}
subtitle={
resolveModelAvailability(
(modelPickerSessionId ? getSessionModelSelection(modelPickerSessionId)?.model : null)
?? local.prefs.defaultModel
?? null,
).status === "unavailable"
? MODEL_PICKER_UNAVAILABLE_SUBTITLE
: undefined
}
target="default"
current={
(modelPickerSessionId ? getSessionModelSelection(modelPickerSessionId)?.model : null)
?? local.prefs.defaultModel
?? ({ providerID: "", modelID: "" } satisfies ModelRef)
}
onSelect={(next: ModelRef) => {
applySessionRouteModelSelection(next, modelPickerSessionId);
setModelPickerSessionId(null);
modelPicker.setOpen(false);
}}
disabledProviders={disabledProviderIds}
onBehaviorChange={() => {}}
onToggleProvider={async (providerId, enable) => {
if (!opencodeClient) return;
try {
const config = unwrap(await opencodeClient.config.get());
const current = disabledProvidersFromConfig(config);
const next = enable
? current.filter((id: string) => id !== providerId)
: [...current, providerId];
const result = await updateManagedDisabledProviders({
opencodeClient,
omnirushClient: selectedWorkspaceEndpoint?.client ?? null,
workspaceId: selectedWorkspaceEndpoint?.workspaceId ?? null,
workspaceType: selectedWorkspace?.workspaceType ?? "local",
disabledProviders: next,
currentConfig: config,
markReloadRequired: () => {
reloadCoordinator.markReloadRequired("config", {
type: "config",
name: "runtime-opencode-config.json",
action: "updated",
});
},
});
setDisabledProviderIds(result.disabledProviders);
} catch {}
}}
onOpenSettings={() => {
modelPicker.setOpen(false);
handleOpenSettings("/settings/general");
}}
onClose={() => { modelPicker.setOpen(false); modelPicker.setRecentProviderIds(new Set()); setModelPickerSessionId(null); }}
omniRushModelsEntitled={omniRushModelsEntitled}
omniRushModelsSyncing={omniRushModelsSyncing}
onRefreshOrganizationModels={refreshOrganizationModelAccess}
restrictToCloud={restrictToCloudProviders}
/>
</WorkspaceProvider>
);
}