Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
import { NativeCallProvider } from '@channel/Call/native-call-state';
import { useCallKitSetup } from '@channel/Call/use-callkit';
import { useAndroidBack } from '@core/mobile/androidBack';
import { useAndroidWindowInsets } from '@core/mobile/androidWindowInsets';
import { NativeAppUpdateRequiredDialog } from '@core/mobile/NativeAppUpdateRequiredDialog';
import { nativeUpdateRequired } from '@core/mobile/nativeUpdateRequired';
import { fireAndForget } from '@core/util/fireAndForget';
import { isPlatform, isTauri } from '@core/util/platform';
import {
hasAutomaticReloadHolds,
syncNativeReloadHold,
} from '@core/util/reloadForNewerBuild';
import { Telemetry } from '@macro-inc/observability';
import { PlatformNotificationProvider } from '@notifications';
import { queryPersistence } from '@queries/client';
import type { RouteSectionProps } from '@solidjs/router';
import { invoke } from '@tauri-apps/api/core';
import { listen } from '@tauri-apps/api/event';
import { type OsType, type as osType } from '@tauri-apps/plugin-os';
import { Dialog, Surface } from '@ui';
import {
type Accessor,
createContext,
createEffect,
createSignal,
type JSX,
onCleanup,
onMount,
useContext,
} from 'solid-js';
import {
createNativeUpdates,
type NativeUpdateStatus,
nativeUpdateDescription,
} from './native-updates';
import { useTauriNavigationEffect } from './navigation';
import { MaybePushNotificationRegistration } from './PushNotification';
import { ShareTargetProvider } from './ShareTargetProvider';
import {
createWaitingForWifiPrompt,
WaitingForWifiUpdateDialog,
} from './WaitingForWifiUpdateDialog';
export type BundleUpdateStatus =
| { status: 'Idle' }
| { status: 'CheckingForUpdate' }
| { status: 'UpdateFound'; data: { version: string; notes: string | null } }
| { status: 'NoUpdateNeeded' }
| { status: 'WaitingForWifi' }
| { status: 'Downloading'; data: { progress: number } }
| { status: 'Unzipping'; data: { progress: number } }
| { status: 'ClearRequired'; data: { reason: string } }
| {
status: 'NativeUpdateRequired';
data: { bundleBuild: number; minNativeBuild: number };
}
| { status: 'Completed' }
| { status: 'Error'; data: { message: string } };
interface TauriContextValue {
os: OsType;
bundleUpdateStatus: Accessor<BundleUpdateStatus>;
nativeUpdateStatus: Accessor<NativeUpdateStatus>;
nativeUpdatePreparing: Accessor<boolean>;
restartNativeUpdate: () => Promise<void>;
registerNativeUpdatePreparation: (save: () => Promise<void>) => () => void;
}
const TauriContext = createContext<TauriContextValue | undefined>(undefined);
const LOADED_BUNDLE_BUILD = (() => {
if (typeof document === 'undefined') return undefined;
const value = document
.querySelector<HTMLMetaElement>('meta[name="macro-bundle-build"]')
?.getAttribute('content');
if (value === undefined || value === null || !/^\d+$/.test(value)) {
return undefined;
}
const bundleBuild = Number(value);
return Number.isSafeInteger(bundleBuild) ? bundleBuild : undefined;
})();
function shouldShowNativeAppUpdateRequiredDialog(status: BundleUpdateStatus) {
return (
status.status === 'ClearRequired' ||
status.status === 'NativeUpdateRequired'
);
}
function TauriProvider(props: { children: JSX.Element }) {
const nativeUpdates = createNativeUpdates(queryPersistence.flush);
useAndroidWindowInsets();
useAndroidBack();
const [bundleUpdateStatus, setBundleUpdateStatus] =
createSignal<BundleUpdateStatus>({ status: 'Idle' });
const waitingForWifiPrompt = createWaitingForWifiPrompt(bundleUpdateStatus);
function receiveBundleUpdateStatus(status: BundleUpdateStatus) {
setBundleUpdateStatus(status);
waitingForWifiPrompt.observe(status);
}
const [
nativeAppUpdateRequiredDialogOpen,
setNativeAppUpdateRequiredDialogOpen,
] = createSignal(false);
let hasShownNativeAppUpdateRequiredDialog = false;
let hasShownNativeUpdateReason = false;
function performBundleUpdate() {
invoke<boolean>('perform_update').catch((e) =>
console.error('[bundle-update] perform_update failed', e)
);
}
createEffect(() => {
const reason = nativeUpdateRequired();
// A missing cache command opens the dialog once with its reason, even
// after the bundle updater's request was dismissed: it replaces a toast.
const showReason = reason !== undefined && !hasShownNativeUpdateReason;
const showBundle =
!hasShownNativeAppUpdateRequiredDialog &&
shouldShowNativeAppUpdateRequiredDialog(bundleUpdateStatus());
if (!showReason && !showBundle) return;
hasShownNativeAppUpdateRequiredDialog = true;
if (reason !== undefined) hasShownNativeUpdateReason = true;
// The App Store prompt wins over the offer to download a bundle off Wi-Fi.
waitingForWifiPrompt.yieldToNativeUpdate();
setNativeAppUpdateRequiredDialogOpen(true);
});
useCallKitSetup();
const value: TauriContextValue = {
os: osType(),
bundleUpdateStatus,
nativeUpdateStatus: nativeUpdates.status,
nativeUpdatePreparing: nativeUpdates.preparing,
restartNativeUpdate: nativeUpdates.restart,
registerNativeUpdatePreparation: nativeUpdates.registerPreparation,
};
onMount(() => {
const unlistenPromise = listen<BundleUpdateStatus>(
'bundle-update-status',
(ev) => {
receiveBundleUpdateStatus(ev.payload);
}
);
if (LOADED_BUNDLE_BUILD !== undefined) {
invoke<boolean>('ack_bundle_update_reload', {
loadedBundleBuild: LOADED_BUNDLE_BUILD,
}).catch((e) =>
console.error('[bundle-update] ack_bundle_update_reload failed', e)
);
}
fireAndForget(syncNativeReloadHold(), 'bundle-update');
// Fetch current status since events emitted before the listener registered are missed
invoke<BundleUpdateStatus>('get_bundle_update_status')
.then((status) => {
receiveBundleUpdateStatus(status);
})
.catch((error) => Telemetry.error(error, { surface: 'bundle-update' }));
onCleanup(() => {
unlistenPromise
.then((unlisten) => unlisten())
.catch((error) => Telemetry.error(error, { surface: 'bundle-update' }));
});
document.body.classList.add('tauri');
document.body.classList.add(`tauri-${value.os}`);
const onBundleUpdateVisibilityChange = () => {
// iOS gives us a short JS execution window after the app is backgrounded.
// Use it to ask Rust to apply a completed bundle before suspension;
// native Ready/Resumed handlers cover cases where this window is missed.
// Leaving the app does not mean nothing is running: switching to Gmail
// for a sign-in code hides the page while its auth sheet is still open.
if (document.hidden && !hasAutomaticReloadHolds()) {
performBundleUpdate();
}
};
document.addEventListener(
'visibilitychange',
onBundleUpdateVisibilityChange
);
onCleanup(() => {
document.removeEventListener(
'visibilitychange',
onBundleUpdateVisibilityChange
);
});
});
return (
<TauriContext.Provider value={value}>
<ShareTargetProvider os={value.os}>{props.children}</ShareTargetProvider>
<Dialog
open={nativeUpdates.preparing()}
onOpenChange={() => {}}
class="w-[90%] max-w-120"
position="center"
>
<Surface depth={2}>
<div class="flex flex-col gap-2 px-4 py-5">
<Dialog.Title class="text-lg font-semibold text-ink">
Restarting Macro
</Dialog.Title>
<Dialog.Description class="text-sm text-ink-extra-muted">
Saving your changes before installing the app update…
</Dialog.Description>
</div>
</Surface>
</Dialog>
<WaitingForWifiUpdateDialog
prompt={waitingForWifiPrompt}
status={bundleUpdateStatus()}
/>
<NativeAppUpdateRequiredDialog
open={nativeAppUpdateRequiredDialogOpen()}
onClose={() => setNativeAppUpdateRequiredDialogOpen(false)}
description={
nativeUpdateRequired() ??
(isPlatform('desktop') && nativeUpdates.status().status !== 'Disabled'
? nativeUpdateDescription(nativeUpdates.status())
: undefined)
}
onRestart={
nativeUpdates.status().status === 'Ready'
? () => fireAndForget(nativeUpdates.restart(), 'native-updates')
: undefined
}
/>
</TauriContext.Provider>
);
}
export function MaybeTauriProvider(props: { children: JSX.Element }) {
if (isTauri()) {
return (
<NativeCallProvider>
<TauriProvider>
<MaybePushNotificationRegistration>
{props.children}
</MaybePushNotificationRegistration>
</TauriProvider>
</NativeCallProvider>
);
}
return (
<PlatformNotificationProvider>
{props.children}
</PlatformNotificationProvider>
);
}
/// return the value of the tauri context
export function useTauri() {
return useContext(TauriContext);
}
/// same as useTauri but throws if the structure of the component tree is invalid
export function useExpectTauri() {
const res = useTauri();
if (res === undefined) {
throw new Error(
'Tauri Context was not found, did you mean to call useTauri instead?'
);
}
return res;
}
/// we need this as a separate component since it must be a child of solidjs Router
export function TauriRouteListener(props: RouteSectionProps) {
if (isTauri()) {
useTauriNavigationEffect();
}
return props.children;
}