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 { fireAndForget } from '@core/util/fireAndForget';
import { format } from 'date-fns/format';
import { isThisYear } from 'date-fns/isThisYear';
import { type Accessor, createSignal } from 'solid-js';
import type {
EmailComposeFeedback,
EmailDelivery,
EmailDraftLifecycleState,
} from '../context/compose-capabilities';
export type EmailDeliveryIntent =
| { type: 'immediate' }
| { type: 'later'; sendTime: Date };
export type EmailScheduleState =
| { type: 'editing'; intent: EmailDeliveryIntent }
| {
type: 'scheduled';
confirmedTime: Date;
proposedTime?: Date;
deliveryStatus?: 'pending' | 'sending' | 'failed' | 'unconfirmed';
};
export type EmailScheduleAction =
| 'send'
| 'schedule'
| 'update'
| 'unavailable';
export function scheduleTimeLocked(state: EmailScheduleState) {
return (
state.type === 'scheduled' &&
state.deliveryStatus !== undefined &&
state.deliveryStatus !== 'pending'
);
}
export function getScheduleSelection(state: EmailScheduleState) {
if (state.type === 'editing') {
return state.intent.type === 'later' ? state.intent.sendTime : undefined;
}
return state.proposedTime ?? state.confirmedTime;
}
export function getScheduleAction(
state: EmailScheduleState
): EmailScheduleAction {
if (state.type === 'editing') {
return state.intent.type === 'later' ? 'schedule' : 'send';
}
if (scheduleTimeLocked(state)) return 'unavailable';
return state.proposedTime ? 'update' : 'unavailable';
}
export function getScheduleActionLabel(state: EmailScheduleState) {
switch (getScheduleAction(state)) {
case 'schedule':
return 'Schedule send';
case 'update':
return 'Update schedule';
default:
return 'Send email';
}
}
const sameTime = (left: Date, right: Date) =>
left.getTime() === right.getTime();
// A schedule's notice outlives the composer that made it: showing the thread
// mounts another composer for the same draft, which may cancel or deliver it.
const scheduledNotices = new Map<string, { toastId: number | undefined }>();
export function createEmailSendSchedule(options: {
delivery: Pick<EmailDelivery, 'schedule' | 'unschedule' | 'archive'>;
notices: EmailComposeFeedback;
initialScheduledTime?: Date;
initialDeliveryStatus?: Extract<
EmailScheduleState,
{ type: 'scheduled' }
>['deliveryStatus'];
draftId: Accessor<string | null | undefined>;
draftGeneration?: Accessor<number>;
saveDraft: () => Promise<string | undefined>;
threadId: Accessor<string | null | undefined>;
/** Scheduling marks the thread done only when this reports it in the inbox. */
threadInInbox?: Accessor<boolean | undefined>;
inboxId: Accessor<string | undefined>;
includeSignature: Accessor<boolean | undefined>;
/** Changes whenever the persisted draft identity or editable content changes. */
generation: Accessor<string>;
lifecycleState?: Accessor<EmailDraftLifecycleState | undefined>;
reconcile?: () => Promise<EmailDraftLifecycleState | undefined>;
reconcileIdentity?: (input: {
draftId: string;
threadId: string;
inboxId?: string;
}) => Promise<EmailDraftLifecycleState | undefined>;
onScheduleUndone?: (input: {
draftId: string;
threadId: string | undefined;
inboxId: string | undefined;
sendTime: Date;
}) => Promise<void> | void;
/** Opens the scheduled message; the success notice offers it when present. */
onViewScheduled?: (input: {
draftId: string;
threadId: string | undefined;
inboxId: string | undefined;
}) => void;
}) {
const { delivery, notices } = options;
const [state, setState] = createSignal<EmailScheduleState>(
options.initialScheduledTime
? {
type: 'scheduled',
confirmedTime: options.initialScheduledTime,
deliveryStatus: options.initialDeliveryStatus,
}
: { type: 'editing', intent: { type: 'immediate' } }
);
const [operation, setOperation] = createSignal<
'idle' | 'committing' | 'updating' | 'cancelling'
>('idle');
let selectionRevision = 0;
let ignoredLifecycleObservation: EmailDraftLifecycleState | undefined;
let deferredLifecycleObservation: EmailDraftLifecycleState | undefined;
// The "Email scheduled" notice offers Undo only while that schedule stands.
// Remember the draft it belongs to past a composer's session reset.
let scheduledDraftId = options.initialScheduledTime
? (options.draftId() ?? undefined)
: undefined;
const dismissScheduledNotice = () => {
const draftId = scheduledDraftId ?? options.draftId();
const notice = draftId ? scheduledNotices.get(draftId) : undefined;
if (!draftId || !notice) return;
scheduledNotices.delete(draftId);
if (notice.toastId != null) notices.feedback.dismiss(notice.toastId);
};
const pending = () => operation() !== 'idle';
const selectedTime = () => getScheduleSelection(state());
const confirmedTime = () => {
const current = state();
return current.type === 'scheduled' ? current.confirmedTime : undefined;
};
/** Picker changes are deliberately local. They never mutate delivery state. */
const select = (date: Date | null): boolean => {
if (pending()) return false;
const before = state();
if (scheduleTimeLocked(before)) return false;
selectionRevision += 1;
setState((current) => {
if (current.type === 'editing') {
return date
? { type: 'editing', intent: { type: 'later', sendTime: date } }
: { type: 'editing', intent: { type: 'immediate' } };
}
if (!date || sameTime(date, current.confirmedTime)) {
return { ...current, proposedTime: undefined };
}
return {
...current,
proposedTime: date,
};
});
return true;
};
const applyScheduled = (
sendTime: Date,
replaceProposal = false,
deliveryStatus?: Extract<
EmailScheduleState,
{ type: 'scheduled' }
>['deliveryStatus']
) => {
const current = state();
if (
!replaceProposal &&
current.type === 'scheduled' &&
sameTime(current.confirmedTime, sendTime) &&
current.proposedTime &&
(!deliveryStatus || deliveryStatus === 'pending')
) {
setState({ ...current, deliveryStatus });
return;
}
scheduledDraftId = options.draftId() ?? scheduledDraftId;
selectionRevision += 1;
setState({ type: 'scheduled', confirmedTime: sendTime, deliveryStatus });
};
const applyEditing = () => {
if (state().type !== 'scheduled') return;
dismissScheduledNotice();
selectionRevision += 1;
setState({ type: 'editing', intent: { type: 'immediate' } });
};
/**
* Apply only authoritative server lifecycle. An ordinary editing observation
* intentionally leaves a local, unconfirmed time choice intact.
*/
const observe = (next: EmailDraftLifecycleState) => {
if (pending()) {
deferredLifecycleObservation = next;
return;
}
if (next === ignoredLifecycleObservation) return;
if (next.type === 'scheduled') {
applyScheduled(new Date(next.sendTime), false, next.deliveryStatus);
return;
}
if (next.type === 'editing') applyEditing();
};
const reconcileScheduleFailure = async (requested: Date) => {
try {
const authoritative = await options.reconcile?.();
if (
authoritative?.type === 'scheduled' &&
new Date(authoritative.sendTime).getTime() === requested.getTime()
) {
return true;
}
} catch (error) {
notices.reportError(error);
}
return false;
};
const undoInitialSchedule = async (input: {
draftId: string;
draftGeneration: number | undefined;
threadId: string | undefined;
inboxId: string | undefined;
sendTime: Date;
markedDone: boolean;
}) => {
try {
await delivery.unschedule({
draftGeneration: input.draftGeneration,
draftId: input.draftId,
threadId: input.threadId,
inboxId: input.inboxId,
});
} catch (error) {
notices.reportError(error);
try {
const authoritative =
input.threadId && options.reconcileIdentity
? await options.reconcileIdentity({
draftId: input.draftId,
threadId: input.threadId,
inboxId: input.inboxId,
})
: await options.reconcile?.();
const matchesCapturedIdentity =
authoritative?.draftId === input.draftId &&
(input.threadId === undefined ||
authoritative.threadId === input.threadId) &&
(input.inboxId === undefined ||
authoritative.inboxId === input.inboxId);
if (matchesCapturedIdentity && authoritative?.type === 'editing') {
// A lost cancellation response is still a successful undo.
} else if (matchesCapturedIdentity && authoritative?.type === 'sent') {
notices.feedback.alert(
'This email was already sent and can no longer be unscheduled.'
);
return;
} else {
notices.feedback.failure('Failed to undo scheduled send');
return;
}
} catch (refreshError) {
notices.reportError(refreshError);
notices.feedback.failure('Failed to undo scheduled send');
return;
}
}
if (options.draftId() === input.draftId) applyEditing();
if (input.markedDone && input.threadId) {
try {
await delivery.archive(
{ threadId: input.threadId, value: false },
input.inboxId
);
} catch (error) {
notices.reportError(error);
notices.feedback.failure('Failed to restore thread to inbox');
}
}
try {
await options.onScheduleUndone?.(input);
notices.feedback.success('Schedule cancelled.');
} catch (error) {
notices.reportError(error);
notices.feedback.alert(
'Schedule cancelled, but the draft could not be reopened. Check Drafts.'
);
}
};
const submit = async (): Promise<'scheduled' | 'updated' | false> => {
const before = state();
const action = getScheduleAction(before);
if (action !== 'schedule' && action !== 'update') return false;
if (pending()) return false;
const requested = getScheduleSelection(before);
if (!requested || !Number.isFinite(requested.getTime())) {
notices.feedback.alert('Choose a valid send time.');
return false;
}
if (requested.getTime() <= Date.now()) {
notices.feedback.alert(
'That send time has passed. Choose a future time.'
);
return false;
}
const revision = selectionRevision;
const generation = options.generation();
const inboxId = options.inboxId();
deferredLifecycleObservation = undefined;
setOperation(action === 'update' ? 'updating' : 'committing');
try {
let draftId: string | undefined;
if (action === 'schedule') {
try {
draftId = await options.saveDraft();
} catch {
// Persistence owns its specific feedback. Never fall through to Send.
return false;
}
} else {
// A confirmed schedule is content-locked; updating its time must not
// rewrite the draft body through the ordinary autosave endpoint.
draftId = options.draftId() ?? undefined;
}
if (
revision !== selectionRevision ||
generation !== options.generation() ||
inboxId !== options.inboxId()
) {
return false;
}
if (!draftId) {
notices.feedback.failure(
action === 'update'
? 'Failed to update schedule'
: 'Failed to schedule email',
{
subtext:
'Draft is not ready to schedule. Resolve any save or connection errors and try again',
}
);
return false;
}
// Undo runs after a reply composer has reset, so it keeps this value.
const draftGeneration = options.draftGeneration?.();
try {
await delivery.schedule(
{
draftGeneration,
draftId,
threadId: options.threadId() ?? undefined,
sendTime: requested.toISOString(),
includeSignature: options.includeSignature(),
},
inboxId
);
} catch (error) {
notices.reportError(error);
if (!(await reconcileScheduleFailure(requested))) {
notices.feedback.failure(
action === 'update'
? 'Failed to update schedule'
: 'Failed to schedule email'
);
return false;
}
}
if (
revision !== selectionRevision ||
generation !== options.generation() ||
inboxId !== options.inboxId()
) {
await options.reconcile?.().catch(notices.reportError);
return false;
}
applyScheduled(requested, true);
const threadId = options.threadId();
let markedDone = false;
const inInbox = options.threadInInbox
? options.threadInInbox() === true
: true;
if (threadId && inInbox) {
try {
await delivery.archive({ threadId, value: true }, inboxId);
markedDone = true;
} catch (error) {
notices.reportError(error);
notices.feedback.failure(
'Email scheduled, but unable to mark thread done'
);
}
}
try {
// The title stays terse so it never truncates; the time is the subtext.
let toastId: number | undefined;
let notice: { toastId: number | undefined } | undefined;
let undoStarted = false;
const onViewScheduled = options.onViewScheduled;
const viewAction = onViewScheduled
? [
{
label: 'View message',
kind: 'open' as const,
onClick: () => {
if (toastId != null) notices.feedback.dismiss(toastId);
onViewScheduled({
draftId,
threadId: threadId ?? undefined,
inboxId,
});
},
},
]
: [];
const undoAction =
action === 'schedule'
? [
{
label: 'Undo',
onClick: () => {
// A dismissing notice stays clickable; only the live one undoes.
if (
undoStarted ||
!notice ||
scheduledNotices.get(draftId) !== notice
)
return;
undoStarted = true;
scheduledNotices.delete(draftId);
if (toastId != null) notices.feedback.dismiss(toastId);
fireAndForget(
undoInitialSchedule({
draftId,
draftGeneration,
threadId: threadId ?? undefined,
inboxId,
sendTime: requested,
markedDone,
}),
'email-compose'
);
},
},
]
: [];
const actions = [...undoAction, ...viewAction];
dismissScheduledNotice();
toastId = notices.feedback.success(
action === 'update' ? 'Email rescheduled' : 'Email scheduled',
{
subtext: `Sends ${format(
requested,
isThisYear(requested)
? "EEE, MMM d 'at' h:mm a"
: "EEE, MMM d, yyyy 'at' h:mm a"
)}`,
...(actions.length > 0 ? { actions, duration: 8_000 } : {}),
}
);
notice = { toastId };
scheduledNotices.set(draftId, notice);
} catch (error) {
// Toast rendering is post-commit UI and cannot make a successful
// schedule retryable.
notices.reportError(error);
}
ignoredLifecycleObservation =
deferredLifecycleObservation ?? options.lifecycleState?.();
return action === 'update' ? 'updated' : 'scheduled';
} finally {
setOperation('idle');
}
};
const cancel = async (): Promise<boolean> => {
const before = state();
if (before.type !== 'scheduled' || pending()) return false;
if (
before.deliveryStatus === 'sending' ||
before.deliveryStatus === 'unconfirmed'
)
return false;
const draftId = options.draftId();
if (!draftId) return false;
const generation = options.generation();
const inboxId = options.inboxId();
deferredLifecycleObservation = undefined;
setOperation('cancelling');
try {
try {
await delivery.unschedule({
draftGeneration: options.draftGeneration?.(),
draftId,
threadId: options.threadId() ?? undefined,
inboxId,
});
} catch (error) {
notices.reportError(error);
try {
const authoritative = await options.reconcile?.();
if (authoritative?.type !== 'editing') {
notices.feedback.failure('Failed to cancel schedule');
return false;
}
} catch (refreshError) {
notices.reportError(refreshError);
notices.feedback.failure('Failed to cancel schedule');
return false;
}
}
if (
generation !== options.generation() ||
inboxId !== options.inboxId()
) {
await options.reconcile?.().catch(notices.reportError);
return false;
}
ignoredLifecycleObservation =
deferredLifecycleObservation ?? options.lifecycleState?.();
applyEditing();
notices.feedback.success(
'Schedule cancelled. This email is editable again.'
);
return true;
} finally {
setOperation('idle');
}
};
const checkStatus = async () => {
try {
const next = await options.reconcile?.();
if (next) observe(next);
} catch (error) {
notices.reportError(error);
notices.feedback.failure(
'Could not check delivery status. Try again when you have service.'
);
}
};
/** Preserve a proposed replacement as inert local intent after detaching. */
const detach = () => {
const current = state();
if (current.type === 'editing') return;
const proposed =
current.type === 'scheduled' ? current.proposedTime : undefined;
dismissScheduledNotice();
selectionRevision += 1;
setState(
proposed
? { type: 'editing', intent: { type: 'later', sendTime: proposed } }
: { type: 'editing', intent: { type: 'immediate' } }
);
};
return {
state,
operation,
pending,
selectedTime,
confirmedTime,
action: () => getScheduleAction(state()),
actionLabel: () => getScheduleActionLabel(state()),
pickerDisabled: () => pending() || scheduleTimeLocked(state()),
select,
submit,
cancel,
checkStatus,
observe,
detach,
reset: () => {
scheduledDraftId = undefined;
selectionRevision += 1;
setState({ type: 'editing', intent: { type: 'immediate' } });
},
};
}