Compare commits

...
Author SHA1 Message Date
Lotus CIandClaude Opus 5.5 56af9520bd test(e2e): scheduled messages and offline outbox; retry rate-limited scheduled-message calls
CI / Build & Quality Checks (push) Skipped
CI / Secret scan (gitleaks) (push) Skipped
CI / Playwright smoke (e2e) (push) Skipped
CI / Build & Quality Checks (pull_request) Successful in 3m16s
CI / Trigger Desktop Build (pull_request) Skipped
CI / Docker image build & smoke test (pull_request) Skipped
CI / Secret scan (gitleaks) (pull_request) Successful in 8s
CI / Playwright smoke (e2e) (pull_request) Successful in 19m2s
New end-to-end coverage for two Lotus features the October audit listed as
untested, checked against the server at each step:
- scheduled-messages.spec: schedule (tray + one delayed event on the
  server), Send now (arrives once, delayed event gone), cancel (gone from the
  server, never sent).
- offline-outbox.spec: offline, three messages show "Queued. Will send when
  you are back online"; back online, the server has each exactly once and in
  order; the queued marks clear.

The scheduled-messages test found a real bug: Synapse rate-limits delayed
event management per user, and a quick Send now then Cancel got a 429, so
the tray showed "Could not cancel this message" although nothing was wrong.
All scheduled-message calls (schedule, list, send now, cancel, restart) now
wait out a 429 (Retry-After, bounded) and retry; scheduling reuses its txnId.
Unit test for the retry helper.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017PCb59uY3UKqDqt7B6hzd5
2026-10-28 06:40:51 -04:00
jared 29ece6a0c8 Merge pull request 'fix(auth): SSO confirmation works in the desktop app; allow switching to SSO' (#474) from fix/sso-uia-desktop into lotus
CI / Secret scan (gitleaks) (push) Successful in 23s
CI / Build & Quality Checks (push) Successful in 1m30s
CI / Docker image build & smoke test (push) Skipped
CI / Trigger Desktop Build (push) Successful in 13s
CI / Playwright smoke (e2e) (push) Successful in 29m16s
2026-10-26 12:12:02 -04:00
Lotus CIandClaude Opus 5.5 f7f6059b33 fix(auth): SSO confirmation works in the desktop app; allow switching to SSO
CI / Build & Quality Checks (push) Skipped
CI / Secret scan (gitleaks) (push) Skipped
CI / Playwright smoke (e2e) (push) Skipped
CI / Secret scan (gitleaks) (pull_request) Successful in 1m50s
CI / Build & Quality Checks (pull_request) Successful in 3m15s
CI / Trigger Desktop Build (pull_request) Skipped
CI / Docker image build & smoke test (pull_request) Skipped
CI / Playwright smoke (e2e) (pull_request) Successful in 18m29s
Reported by a desktop user: signing out other sessions with SSO looped.
Server logs: the SSO step completed every time, but each delete_devices
retry came without the session (a fresh 401 challenge), 4 attempts, none
succeeded. The app is the Windows desktop build (WebView2) and the SSO
pages opened in the system browser.

- SSOStage only offered "Continue" once window.open returned a window. The
  desktop app opens the page in the system browser (no window back), and a
  popup can lose its opener, so "authDone" never arrives and the only way
  on was starting over. Now "Continue" (plus "Open the sign-in page again")
  appears as soon as the page was opened; authDone still auto-continues.
- ActionUIA: when the server offers password and SSO, the first flow was
  forced (often password, which an SSO-only account may not know). Offer
  "Use SSO instead" / "Use your password instead".

e2e: desktop (window.open returns null) completes with the session; with
password offered first, SSO is one click away.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017PCb59uY3UKqDqt7B6hzd5
2026-10-26 11:49:52 -04:00
jared 71b7619082 Merge pull request 'chore(build): ship only the DTLN files that can load (-9 MB) (#210)' (#470) from chore/build-hygiene into lotus
CI / Build & Quality Checks (push) Successful in 3m41s
CI / Docker image build & smoke test (push) Skipped
CI / Secret scan (gitleaks) (push) Successful in 18s
CI / Trigger Desktop Build (push) Successful in 6s
CI / Playwright smoke (e2e) (push) Successful in 29m27s
2026-10-25 22:48:04 -04:00
Lotus CIandClaude Opus 5.5 d5b0b40b17 chore(build): ship only the DTLN files that can load (-9 MB) (#210)
CI / Build & Quality Checks (push) Skipped
CI / Secret scan (gitleaks) (push) Skipped
CI / Playwright smoke (e2e) (push) Skipped
CI / Secret scan (gitleaks) (pull_request) Successful in 24s
CI / Build & Quality Checks (pull_request) Successful in 3m2s
CI / Trigger Desktop Build (pull_request) Skipped
CI / Docker image build & smoke test (pull_request) Skipped
CI / Playwright smoke (e2e) (pull_request) Successful in 30m35s
The DTLN noise-suppression package was copied whole into every build
(57 MB). Its threaded LiteRT build is only used on a cross-origin-isolated
page, and neither the web nor the desktop call page is (no COOP/COEP), so
its ~9 MB could never load; source maps and .d.ts files aren't needed at
runtime either. Leave those out: 57 -> 48 MB per web deploy and desktop
installer. Verified on the built output, not isolated: the DTLN worklet
reaches ready and runs a 300-frame benchmark, no 404s.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017PCb59uY3UKqDqt7B6hzd5
2026-10-25 20:17:20 -04:00
8 changed files with 434 additions and 40 deletions

No files matched your search

+72
View File
@@ -0,0 +1,72 @@
import { test, expect } from '@playwright/test';
import {
api,
createRoom,
enc,
ensureUser,
hsReachable,
loginUI,
openRoom,
sendText,
uniq,
} from './localHs';
// Offline outbox (#112): messages sent while offline are queued, then
// delivered once each, in order, when the connection returns. Checked on the
// server, so duplicates or reordering would show.
test.describe('offline outbox', () => {
test.beforeAll(async () => {
test.skip(!(await hsReachable()), 'local homeserver not running');
});
test('queued while offline, delivered once each and in order when back', async ({
page,
context,
}) => {
test.setTimeout(120_000);
const me = await ensureUser(uniq('outbox'));
const room = await createRoom(me, 'Outbox Room');
await sendText(me, room, 'before going offline');
await loginUI(page, me);
await openRoom(page, room);
await expect(page.getByText('before going offline')).toBeVisible();
await context.setOffline(true);
const composer = page.getByRole('textbox', { name: /message/i }).last();
const texts = [uniq('one '), uniq('two '), uniq('three ')];
for (const text of texts) {
// eslint-disable-next-line no-await-in-loop
await composer.fill(text);
// eslint-disable-next-line no-await-in-loop
await composer.press('Enter');
}
for (const text of texts) {
const item = page.locator('[data-message-item]', { hasText: text });
// eslint-disable-next-line no-await-in-loop
await expect(item).toHaveCount(1);
// eslint-disable-next-line no-await-in-loop
await expect(item.getByLabel(/^Queued\. Will send when you're back online/)).toBeVisible({
timeout: 20_000,
});
}
await context.setOffline(false);
const bodiesOnServer = async () => {
const res = await api<{ chunk: { type: string; content?: { body?: string } }[] }>(
'GET',
`/_matrix/client/v3/rooms/${enc(room)}/messages?dir=f&limit=100`,
me.token,
);
return res.chunk
.filter((e) => e.type === 'm.room.message' && texts.includes(e.content?.body ?? ''))
.map((e) => e.content?.body);
};
await expect.poll(bodiesOnServer, { timeout: 60_000, intervals: [1000] }).toEqual(texts);
for (const text of texts) {
// eslint-disable-next-line no-await-in-loop
await expect(
page.locator('[data-message-item]', { hasText: text }).getByLabel(/^Queued/),
).toHaveCount(0, { timeout: 20_000 });
}
});
});
+102
View File
@@ -0,0 +1,102 @@
import { test, expect, Page } from '@playwright/test';
import {
api,
createRoom,
enc,
ensureUser,
hsReachable,
loginUI,
openRoom,
sendText,
uniq,
} from './localHs';
// Scheduled messages (MSC4140 delayed events). Each step is checked on the
// server too, so this proves the delayed event really exists, fires and is
// cancelled, not just that the tray looks right.
type Delayed = { delayed_events?: { delay_id: string; room_id: string }[] };
const delayedOnServer = (token: string) =>
api<Delayed>('GET', '/_matrix/client/unstable/org.matrix.msc4140/delayed_events', token).then(
(r) => r.delayed_events ?? [],
);
// The tray remembers whether it is open; open it only if its rows are hidden.
const openTray = async (page: Page) => {
const rowButton = page.getByRole('button', { name: /^Cancel scheduled message: / });
if (await rowButton.count()) return;
await page.getByRole('button', { name: /^\d+ scheduled messages?$/ }).click();
await expect(rowButton.first()).toBeVisible();
};
const schedule = async (page: Page, text: string) => {
await page.getByRole('button', { name: 'Schedule message' }).click();
const dialog = page.getByRole('dialog', { name: 'Schedule message' });
await dialog.locator('#schedule-message-body').fill(text);
// Two hours ahead, in the browser's own time zone.
const { date, time } = await page.evaluate(() => {
const d = new Date(Date.now() + 2 * 60 * 60 * 1000);
const p = (n: number) => String(n).padStart(2, '0');
return {
date: `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`,
time: `${p(d.getHours())}:${p(d.getMinutes())}`,
};
});
await dialog.locator('#schedule-date').fill(date);
await dialog.locator('#schedule-time').fill(time);
await dialog.getByRole('button', { name: 'Schedule', exact: true }).click();
await expect(dialog).toHaveCount(0);
};
test.describe('scheduled messages', () => {
test.beforeAll(async () => {
test.skip(!(await hsReachable()), 'local homeserver not running');
});
test('schedule, send now, and cancel — the server agrees at each step', async ({ page }) => {
test.setTimeout(120_000);
const me = await ensureUser(uniq('sched'));
const room = await createRoom(me, 'Schedule Room');
await sendText(me, room, 'room is ready');
await loginUI(page, me);
await openRoom(page, room);
// 1. Schedule: tray shows it, the server holds one delayed event.
const first = uniq('later ');
await schedule(page, first);
await expect(page.getByRole('button', { name: '1 scheduled message' })).toBeVisible();
await expect
.poll(async () => (await delayedOnServer(me.token)).length, { intervals: [1000] })
.toBe(1);
expect((await delayedOnServer(me.token))[0].room_id).toBe(room);
await expect(page.locator('[data-message-item]', { hasText: first })).toHaveCount(0);
// 2. Send now: it arrives once, the delayed event is gone.
await openTray(page);
await page.getByRole('button', { name: /^Send scheduled message now: / }).click();
await expect(page.locator('[data-message-item]', { hasText: first })).toHaveCount(1, {
timeout: 20_000,
});
await expect
.poll(async () => (await delayedOnServer(me.token)).length, { intervals: [1000] })
.toBe(0);
// 3. Cancel: removed from the server and never sent.
const second = uniq('never ');
await schedule(page, second);
await expect
.poll(async () => (await delayedOnServer(me.token)).length, { intervals: [1000] })
.toBe(1);
await openTray(page);
await page.getByRole('button', { name: /^Cancel scheduled message: / }).click();
await expect
.poll(async () => (await delayedOnServer(me.token)).length, { intervals: [1000] })
.toBe(0);
await expect(page.getByRole('button', { name: /scheduled message/ })).toHaveCount(0);
const msgs = await api<{ chunk: { content?: { body?: string } }[] }>(
'GET',
`/_matrix/client/v3/rooms/${enc(room)}/messages?dir=b&limit=50`,
me.token,
);
expect(msgs.chunk.some((e) => e.content?.body === second)).toBe(false);
});
});
+83
View File
@@ -0,0 +1,83 @@
import { test, expect, Page } from '@playwright/test';
import { api, ensureUser, hsReachable, loginUI, PASSWORD } from './localHs';
// Signing out other devices with SSO confirmation. The desktop app opens the SSO
// page in the system browser (window.open gives no window back), so the dialog
// must still offer "Continue" — before the fix the only way on was starting
// over, in a loop (reported by a desktop SSO user). The server is mocked: the
// retry succeeds only if it carries the challenge's session.
const openDevicesAndSignOutOther = async (page: Page, flows: string[][]) => {
const sent: unknown[] = [];
await page.route('**/delete_devices', async (route) => {
const body = JSON.parse(route.request().postData() ?? '{}');
sent.push(body.auth ?? null);
if (body.auth?.session === 'S1') {
return route.fulfill({ status: 200, contentType: 'application/json', body: '{}' });
}
return route.fulfill({
status: 401,
contentType: 'application/json',
body: JSON.stringify({
session: 'S1',
flows: flows.map((stages) => ({ stages })),
params: {},
}),
});
});
await page.getByRole('button', { name: 'User Settings' }).click();
const dialog = page.getByRole('dialog').first();
await dialog.getByText('Privacy & security', { exact: true }).first().click();
const card = dialog
.getByText('Old laptop', { exact: true })
.locator('xpath=ancestor::*[.//button][1]');
await card.getByRole('button').nth(1).click(); // the delete chip
const bar = dialog.getByText(/Logout from selected devices/);
await bar
.locator('xpath=ancestor::*[.//button[normalize-space()="Logout"]][1]')
.getByRole('button', { name: 'Logout', exact: true })
.click();
return { sent, bar };
};
test.describe('SSO confirmation for signing out devices', () => {
test.beforeAll(async () => {
test.skip(!(await hsReachable()), 'local homeserver not running');
});
test('desktop: no popup window, Continue still completes it', async ({ page }) => {
test.setTimeout(120_000);
await page.addInitScript(() => {
window.open = () => null; // the desktop app hands the page to the system browser
});
const user = await ensureUser(`ssod${Date.now().toString(36)}`);
await api('POST', '/_matrix/client/v3/login', undefined, {
type: 'm.login.password',
identifier: { type: 'm.id.user', user: user.localpart },
password: PASSWORD,
initial_device_display_name: 'Old laptop',
});
await loginUI(page, user);
const { sent, bar } = await openDevicesAndSignOutOther(page, [['m.login.sso']]);
await page.getByRole('button', { name: 'Continue with SSO' }).click();
await page.getByRole('button', { name: 'Continue', exact: true }).click();
await expect(bar).toHaveCount(0);
expect(sent).toEqual([null, { session: 'S1' }]);
});
test('password offered first: SSO is still one click away', async ({ page }) => {
test.setTimeout(120_000);
const user = await ensureUser(`ssop${Date.now().toString(36)}`);
await api('POST', '/_matrix/client/v3/login', undefined, {
type: 'm.login.password',
identifier: { type: 'm.id.user', user: user.localpart },
password: PASSWORD,
initial_device_display_name: 'Old laptop',
});
await loginUI(page, user);
await openDevicesAndSignOutOther(page, [['m.login.password'], ['m.login.sso']]);
await expect(page.getByText('Account Password').first()).toBeVisible();
await page.getByRole('button', { name: 'Use SSO instead' }).click();
await expect(page.getByRole('button', { name: 'Continue with SSO' })).toBeVisible();
await expect(page.getByRole('button', { name: 'Use your password instead' })).toBeVisible();
});
});
+30 -3
View File
@@ -1,4 +1,5 @@
import React, { ReactNode } from 'react'; import React, { ReactNode, useState } from 'react';
import { Box, Button, Text } from 'folds';
import { AuthDict, AuthType, IAuthData, UIAFlow } from 'matrix-js-sdk'; import { AuthDict, AuthType, IAuthData, UIAFlow } from 'matrix-js-sdk';
import { getUIAFlowForStages } from '../utils/matrix-uia'; import { getUIAFlowForStages } from '../utils/matrix-uia';
import { useSupportedUIAFlows, useUIACompleted, useUIAFlow } from '../hooks/useUIAFlows'; import { useSupportedUIAFlows, useUIACompleted, useUIAFlow } from '../hooks/useUIAFlows';
@@ -23,7 +24,18 @@ type ActionUIAProps = {
export function ActionUIA({ authData, ongoingFlow, action, onCancel }: ActionUIAProps) { export function ActionUIA({ authData, ongoingFlow, action, onCancel }: ActionUIAProps) {
const mx = useMatrixClient(); const mx = useMatrixClient();
const completed = useUIACompleted(authData); const completed = useUIACompleted(authData);
const { getStageToComplete } = useUIAFlow(authData, ongoingFlow); // The server may offer several ways to confirm (e.g. password or SSO). Start
// with the given one but let the user switch: an account that signs in with
// SSO may have no password it knows.
const supportedFlows = useSupportedUIAFlows(authData.flows ?? [], SUPPORTED_IN_APP_UIA_STAGES);
const [flow, setFlow] = useState<UIAFlow>(ongoingFlow);
const { getStageToComplete } = useUIAFlow(authData, flow);
const other = supportedFlows.find((f) => f.stages.join() !== flow.stages.join());
const otherLabel = other?.stages.includes(AuthType.Sso)
? 'Use SSO instead'
: other?.stages.includes(AuthType.Password)
? 'Use your password instead'
: undefined;
const stageToComplete = getStageToComplete(); const stageToComplete = getStageToComplete();
@@ -31,7 +43,7 @@ export function ActionUIA({ authData, ongoingFlow, action, onCancel }: ActionUIA
return ( return (
<UIAFlowOverlay <UIAFlowOverlay
currentStep={completed.length + 1} currentStep={completed.length + 1}
stepCount={ongoingFlow.stages.length} stepCount={flow.stages.length}
onCancel={onCancel} onCancel={onCancel}
> >
{stageToComplete.type === AuthType.Password && ( {stageToComplete.type === AuthType.Password && (
@@ -50,6 +62,21 @@ export function ActionUIA({ authData, ongoingFlow, action, onCancel }: ActionUIA
submitAuthDict={action} submitAuthDict={action}
/> />
)} )}
{other && otherLabel && completed.length === 0 && (
<Box justifyContent="Center" style={{ marginTop: 8 }}>
<Button
size="300"
variant="Secondary"
fill="Soft"
radii="300"
onClick={() => setFlow(other)}
>
<Text as="span" size="B300">
{otherLabel}
</Text>
</Button>
</Box>
)}
</UIAFlowOverlay> </UIAFlowOverlay>
); );
} }
+23 -7
View File
@@ -12,6 +12,12 @@ export function SSOStage({
}) { }) {
const { errorCode, error, session } = stageData; const { errorCode, error, session } = stageData;
const [ssoWindow, setSSOWindow] = useState<Window>(); const [ssoWindow, setSSOWindow] = useState<Window>();
// Whether the SSO page was opened. Not the same as having a window handle:
// the desktop app opens it in the system browser and gets none back, and a
// popup can lose its link to us (cross-origin opener policy on the identity
// provider). In both cases "authDone" never arrives, so "Continue" must still
// be offered once the page was opened, or the only way on is starting over.
const [started, setStarted] = useState(false);
const handleSubmit = useCallback(() => { const handleSubmit = useCallback(() => {
submitAuthDict({ submitAuthDict({
@@ -22,6 +28,7 @@ export function SSOStage({
const handleContinue = () => { const handleContinue = () => {
const w = window.open(ssoRedirectURL, '_blank'); const w = window.open(ssoRedirectURL, '_blank');
setSSOWindow(w ?? undefined); setSSOWindow(w ?? undefined);
setStarted(true);
}; };
useEffect(() => { useEffect(() => {
@@ -74,7 +81,9 @@ export function SSOStage({
gap="400" gap="400"
> >
<Text size="T200"> <Text size="T200">
To perform this action you need to authenticate yourself by SSO login. {started
? 'Finish signing in on the page that opened, then come back here and select Continue.'
: 'To do this, confirm it’s you by signing in with SSO.'}
</Text> </Text>
{errorCode && ( {errorCode && (
<Box alignItems="Center" gap="100" style={{ color: color.Critical.Main }}> <Box alignItems="Center" gap="100" style={{ color: color.Critical.Main }}>
@@ -85,12 +94,19 @@ export function SSOStage({
</Box> </Box>
)} )}
{ssoWindow ? ( {started ? (
<Button variant="Primary" onClick={handleSubmit}> <Box direction="Column" gap="200">
<Text as="span" size="B400"> <Button variant="Primary" onClick={handleSubmit}>
Continue <Text as="span" size="B400">
</Text> Continue
</Button> </Text>
</Button>
<Button variant="Secondary" fill="None" onClick={handleContinue}>
<Text as="span" size="B400">
Open the sign-in page again
</Text>
</Button>
</Box>
) : ( ) : (
<Button variant="Primary" onClick={handleContinue}> <Button variant="Primary" onClick={handleContinue}>
<Text as="span" size="B400"> <Text as="span" size="B400">
+40
View File
@@ -191,3 +191,43 @@ test('[#275] the server limit maps to friendly text; other errors keep theirs',
assert.equal(describeScheduleError(new Error('Boom')), 'Boom'); assert.equal(describeScheduleError(new Error('Boom')), 'Boom');
assert.equal(describeScheduleError('nope'), 'Failed to schedule message.'); assert.equal(describeScheduleError('nope'), 'Failed to schedule message.');
}); });
test('withRateLimitRetry: waits out a 429 then succeeds; other errors and over-budget waits throw', async () => {
const { withRateLimitRetry } = await import('./scheduledMessages');
const { MatrixError } = await import('matrix-js-sdk');
const limited = () => new MatrixError({ errcode: 'M_LIMIT_EXCEEDED', retry_after_ms: 1500 }, 429);
const sleeps: number[] = [];
const sleepFn = async (ms: number) => {
sleeps.push(ms);
};
let calls = 0;
const ok = await withRateLimitRetry(
async () => {
calls += 1;
if (calls < 3) throw limited();
return 'done';
},
{ sleepFn },
);
assert.equal(ok, 'done');
assert.deepEqual(sleeps, [1500, 1500]);
await assert.rejects(
withRateLimitRetry(
async () => {
throw new MatrixError({ errcode: 'M_FORBIDDEN' }, 403);
},
{ sleepFn },
),
/M_FORBIDDEN|403/,
);
await assert.rejects(
withRateLimitRetry(
async () => {
throw limited();
},
{ sleepFn, maxWaitMs: 2000 },
),
);
});
+73 -29
View File
@@ -1,4 +1,4 @@
import { IContent, MatrixClient, Method } from 'matrix-js-sdk'; import { IContent, MatrixClient, MatrixError, Method } from 'matrix-js-sdk';
import type { ScheduledMessage } from '../state/scheduledMessages'; import type { ScheduledMessage } from '../state/scheduledMessages';
/** /**
@@ -17,6 +17,40 @@ export const describeScheduleError = (err: unknown): string => {
return err instanceof Error ? err.message : 'Failed to schedule message.'; return err instanceof Error ? err.message : 'Failed to schedule message.';
}; };
/**
* Synapse rate-limits delayed-event management per user (listing, send now,
* cancel, restart all count). A quick "Send now" then "Cancel" could get a 429
* and show "Could not cancel" although nothing was wrong. Wait out the
* Retry-After (bounded) and try again. Retrying is safe: a 429 means the
* request was not processed, and scheduling reuses its txnId.
*/
export async function withRateLimitRetry<T>(
fn: () => Promise<T>,
opts: { maxWaitMs?: number; sleepFn?: (ms: number) => Promise<void> } = {},
): Promise<T> {
const maxWaitMs = opts.maxWaitMs ?? 15_000;
const sleepFn =
opts.sleepFn ??
((ms: number) =>
new Promise<void>((r) => {
setTimeout(r, ms);
}));
let waited = 0;
for (;;) {
try {
// eslint-disable-next-line no-await-in-loop
return await fn();
} catch (e) {
if (!(e instanceof MatrixError) || e.httpStatus !== 429) throw e;
const wait = Math.min(Math.max(e.getRetryAfterMs() ?? 1000, 200), 10_000);
if (waited + wait > maxWaitMs) throw e;
waited += wait;
// eslint-disable-next-line no-await-in-loop
await sleepFn(wait);
}
}
}
/** /**
* Schedule a message via MSC4140 (delayed messages). * Schedule a message via MSC4140 (delayed messages).
* Synapse implementation: pass org.matrix.msc4140.delay on the standard * Synapse implementation: pass org.matrix.msc4140.delay on the standard
@@ -42,13 +76,15 @@ export async function scheduleMessage(
const txnId = `sched_${Date.now()}_${Math.random().toString(36).slice(2)}`; const txnId = `sched_${Date.now()}_${Math.random().toString(36).slice(2)}`;
const path = `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`; const path = `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`;
// Use standard v3 prefix with the MSC4140 delay query param. // Use standard v3 prefix with the MSC4140 delay query param.
const res = (await mx.http.authedRequest( const res = (await withRateLimitRetry(() =>
Method.Put, mx.http.authedRequest(
path, Method.Put,
{ path,
'org.matrix.msc4140.delay': delayMs, {
}, 'org.matrix.msc4140.delay': delayMs,
content, },
content,
),
)) as { delay_id: string }; )) as { delay_id: string };
return res.delay_id; return res.delay_id;
} }
@@ -58,23 +94,27 @@ export async function scheduleMessage(
*/ */
export async function cancelScheduledMessage(mx: MatrixClient, delayId: string): Promise<void> { export async function cancelScheduledMessage(mx: MatrixClient, delayId: string): Promise<void> {
const path = `/delayed_events/${encodeURIComponent(delayId)}`; const path = `/delayed_events/${encodeURIComponent(delayId)}`;
await mx.http.authedRequest( await withRateLimitRetry(() =>
Method.Post, mx.http.authedRequest(
path, Method.Post,
undefined, path,
{ action: 'cancel' }, undefined,
{ prefix: '/_matrix/client/unstable/org.matrix.msc4140' }, { action: 'cancel' },
{ prefix: '/_matrix/client/unstable/org.matrix.msc4140' },
),
); );
} }
export async function restartScheduledMessage(mx: MatrixClient, delayId: string): Promise<void> { export async function restartScheduledMessage(mx: MatrixClient, delayId: string): Promise<void> {
const path = `/delayed_events/${encodeURIComponent(delayId)}`; const path = `/delayed_events/${encodeURIComponent(delayId)}`;
await mx.http.authedRequest( await withRateLimitRetry(() =>
Method.Post, mx.http.authedRequest(
path, Method.Post,
undefined, path,
{ action: 'restart' }, undefined,
{ prefix: '/_matrix/client/unstable/org.matrix.msc4140' }, { action: 'restart' },
{ prefix: '/_matrix/client/unstable/org.matrix.msc4140' },
),
); );
} }
@@ -85,12 +125,14 @@ export async function restartScheduledMessage(mx: MatrixClient, delayId: string)
*/ */
export async function sendScheduledMessageNow(mx: MatrixClient, delayId: string): Promise<void> { export async function sendScheduledMessageNow(mx: MatrixClient, delayId: string): Promise<void> {
const path = `/delayed_events/${encodeURIComponent(delayId)}`; const path = `/delayed_events/${encodeURIComponent(delayId)}`;
await mx.http.authedRequest( await withRateLimitRetry(() =>
Method.Post, mx.http.authedRequest(
path, Method.Post,
undefined, path,
{ action: 'send' }, undefined,
{ prefix: '/_matrix/client/unstable/org.matrix.msc4140' }, { action: 'send' },
{ prefix: '/_matrix/client/unstable/org.matrix.msc4140' },
),
); );
} }
@@ -138,9 +180,11 @@ export function parseDelayedEvents(res: unknown): ScheduledMessage[] {
/** The user's pending scheduled messages, as the server has them. */ /** The user's pending scheduled messages, as the server has them. */
export async function fetchScheduledMessages(mx: MatrixClient): Promise<ScheduledMessage[]> { export async function fetchScheduledMessages(mx: MatrixClient): Promise<ScheduledMessage[]> {
const res = await mx.http.authedRequest(Method.Get, '/delayed_events', undefined, undefined, { const res = await withRateLimitRetry(() =>
prefix: '/_matrix/client/unstable/org.matrix.msc4140', mx.http.authedRequest(Method.Get, '/delayed_events', undefined, undefined, {
}); prefix: '/_matrix/client/unstable/org.matrix.msc4140',
}),
);
return parseDelayedEvents(res); return parseDelayedEvents(res);
} }
+11 -1
View File
@@ -189,7 +189,17 @@ function lotusDenoise() {
'Run `npm ci` to install @workadventure/noise-suppression.', 'Run `npm ci` to install @workadventure/noise-suppression.',
); );
} }
fs.cpSync(dtln[0], path.join(denoiseDir, dtln[1]), { recursive: true }); // [Gitea #210] Ship only what can load. The threaded LiteRT build is used
// only on a cross-origin-isolated page (COOP + COEP), and neither the web
// call page nor the desktop one is, so its ~9 MB never loads; source maps
// and type declarations aren't needed at runtime either. If the call page
// ever turns on COOP/COEP, drop the `threaded` exclusion.
const dtlnSkip = (src) =>
/litert_wasm_threaded_internal\./.test(src) || /\.(map|d\.ts)$/.test(src);
fs.cpSync(dtln[0], path.join(denoiseDir, dtln[1]), {
recursive: true,
filter: (src) => !dtlnSkip(src),
});
const dfnMissing = dfn.filter(([s]) => !fs.existsSync(s)).map(([s]) => s); const dfnMissing = dfn.filter(([s]) => !fs.existsSync(s)).map(([s]) => s);
if (dfnMissing.length > 0) { if (dfnMissing.length > 0) {