@acms-subir/core 0.3.9 → 0.3.10

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # @acms-subir/core
 
+## 0.3.10
+
+### Patch Changes
+
+- Apps can now do most of what the website does, with protection against abuse built in.
+
+  - **Manage a booking from the app.** People can see, cancel, move or add to their calendar a booking made in the app or on the website, using its private link. The token goes in a header, never the URL, and repeated wrong tokens lock the caller out for a while. New `manageBooking`, `cancelBooking`, `rescheduleAvailability`, `rescheduleBooking` and `bookingIcs` in the client; `useManagedBooking`, `useCancelBooking`, `useRescheduleBooking` and `useRescheduleAvailability` in native.
+  - **"My bookings" with guest sign-in.** A visitor enters their email, gets a 6-digit code, and sees every booking and RSVP made with that address. Codes and tokens are stored hashed, codes expire after 10 minutes and 5 tries (counted safely even when requests arrive at once), each code signs in only once, and replies never reveal whether an address has bookings. Needs email sending. `useGuest()` and `useMyBookings()` in native; the guest token is saved per site and only ever sent to the site that issued it.
+  - **Links page and forms in apps.** `GET /api/v1/links` and published forms (`GET /api/v1/forms/{id}`, `POST …/responses`) with the web form's validation, retry-safe submissions and a daily limit per form (retries and invalid answers don't use it up). `useLinks`, `useForm` and `useSubmitForm`.
+  - **Staff run the schedule from the staff app.** A week or month schedule view in one request, booking on someone's behalf, moving bookings, blocking time, and managing rooms, booking types, hours and calendars. Form responses and the links page too. Changing rooms, hours and calendars is limited to administrators and owners by default; reading form responses and editing raw HTML link blocks always are. `me().permissions` reports what each person may do.
+  - **Admin → Mobile app → App access** (owners): switch each app feature off instantly, sign every guest device out, and set limits (bookings per email per day, default 10, which also applies to website bookings but not to staff booking for someone; responses per form per day) and who may change the schedule setup.
+  - **Change cutoff for booking types:** "Guests can change until X hours before" stops guests cancelling or moving close to the start, on the website and in apps. Off by default.
+  - **Fix: booking lengths.** A booking (website, app or staff) can only use one of its booking type's lengths. Before, sending a custom `minutes` could hold a 30-minute slot type for hours.
+  - **Fix: day bookings across a clock change.** A whole-day booking on a day when clocks go back or forward (23 or 25 hours long) could not be booked or moved. The end now snaps to the real local midnight on the website, in apps and for staff.
+  - **Fix: rooms with all-day hours and single-day overrides.** The staff app now accepts hours that run to midnight (`00:00` end) and a date override without an end date, and refuses impossible times like `09:99`.
+  - **Fix: client retries.** The client no longer automatically repeats requests that can't safely run twice (sign-in code requests and exchanges, cancelling and moving a booking). When a rate limit asks for a longer wait than the request timeout, the 429 is returned at once with its `retryAfter` instead of ending as a timeout. Rate limits now give their real wait in `Retry-After` (for example an hour for the sign-in email cap).
+  - **Links page edits can't overwrite each other.** The staff app's links page carries a revision: a save made from an out-of-date copy (someone else changed it in an app or on the website) answers 409 and saves nothing, and a save that fails partway leaves the page as it was. Click counts don't count as changes.
+
+- Search in apps. Apps can now search the site the same way the website's search box does: titles count most, then excerpts, tags and body text, and results keep up as people type.
+
+  - **Search one collection:** `GET /api/v1/content?q=` returns ranked matches in the normal list format, so `posts({ collection: 'sermons', q })` in the client and `usePosts({ collection: 'sermons', q })` in native show a filtered sermon list with no other changes.
+  - **Search everything:** the new `GET /api/v1/search?q=` returns the top matches in posts, pages and events on public calendars, each with a plain-text snippet and the ranges of the matched words to highlight, plus a "more" flag for each group. Use `client.search(text)` or the native `useSearch(text)` hook, which waits for typing to pause and fetches nothing for a blank box. `useDebounced(value)` is exported for your own search fields.
+  - Both follow `acms({ search })`: when search is off, `/api/v1/search` isn't registered and `q` returns a 400. Documented in the OpenAPI spec and `docs/mobile-api-v1.md`.
+  - Event results: public events are found even when private events match the query more strongly, and `GET /api/v1/events?q=` matches the same events as `/search` (including body text and word beginnings), so a "more events" screen continues the same results by date.
+
+- Uptime monitoring with Uptime Kuma, so you know within minutes when a site, its app API or its scheduled jobs stop.
+
+  - **`GET /api/health`**: a public health check for monitors. 503 when the database or the scheduler is down, `degraded` (still 200) when email is stuck. It names only the failing part.
+  - **Scheduler heartbeat**: after every scheduled run the site reports to a Kuma push monitor, which goes down when the reports stop (no reminders, scheduled posts or emails). Set the URL in Admin → Settings → Monitoring or `UPTIME_PUSH_URL`.
+  - **`npx acms monitor kuma`**: creates the website, app API, staff app API, health and scheduler monitors plus a status page in your Kuma (1.23 or 2.x) in one go. Reruns update instead of duplicating; `--print` lists them to add by hand. The Kuma login comes from `KUMA_USERNAME` / `KUMA_PASSWORD` (+ `KUMA_TOTP`).
+  - **Admin → Settings → Monitoring** (owners): this site's own health, each Kuma monitor's state and 24-hour uptime, and the heartbeat with a "Send test" button.
+  - `acms mobile doctor` warns when `/api/health` isn't ok, and the authenticated `/api/ops/status` now answers 503 when it reports a problem.
+
 ## 0.3.9
 
 ### Patch Changes

package/cli/common.mjs

@@ -15,8 +15,8 @@ export async function project(root=process.cwd()) {
   return {cwd,pkg,core,version:(await readJson(resolve(core,'package.json'))).version};
 }
 export function parse(argv) {
-  const positionals=[],flags={};const values=new Set(['cwd','site','from','output','baseline','file','url','token-env','revision','days','port','format','tool','theme','as','name','dir','bundle']);
-  const booleans=new Set(['json','help','yes','dry-run','check','next','latest','provision','draft','build','optimize','force','native','offline','mobile','no-config']);
+  const positionals=[],flags={};const values=new Set(['cwd','site','from','output','baseline','file','url','token-env','revision','days','port','format','tool','theme','as','name','dir','bundle','kuma']);
+  const booleans=new Set(['json','help','yes','dry-run','check','next','latest','provision','draft','build','optimize','force','native','offline','mobile','no-config','print']);
   for(let i=0;i<argv.length;i++) {
     let a=argv[i];if(a==='-h')a='--help';if(a==='-y')a='--yes';
     if(!a.startsWith('--')){positionals.push(a);continue;}

package/cli/main.mjs

@@ -7,6 +7,7 @@ import { sectionCommand } from './sections.mjs';
 import { remoteCommand } from './remote.mjs';
 import { addMobile, mobileCommand, listApps } from './mobile.mjs';
 import { mobileDoctor, renderDoctor } from './mobile-doctor.mjs';
+import { monitorCommand, renderMonitor } from './monitor.mjs';
 const HELP=`acms — ACMS project, theme and agent tools
 Discovery: inspect | schema theme | docs theme | docs sections | docs mobile
            agent init [--mobile]   write .agents/skills (theme; mobile when an app exists)
@@ -44,6 +45,10 @@ Mobile: add mobile [client] [--dir mobile] [--name "Riverside"]
                client: events news booking push
                editor: editor-content editor-writer editor-sections
                        editor-translations editor-media editor-bookings
+Monitoring: monitor kuma [--url https://site] [--kuma https://kuma] [--print]
+               website, app API, staff app API, health and scheduler
+               monitors + a status page in Uptime Kuma; reruns update.
+               Login: KUMA_USERNAME, KUMA_PASSWORD (+ KUMA_TOTP)
 Maintenance: update [--check|--next|--latest] | doctor
              add cloudflare [--provision] | add docker
 Global: --json --cwd <dir> --site <profile> --dry-run --yes --help
@@ -105,6 +110,7 @@ export async function main() {
       if(!flags.json){console.log(renderDoctor(data));return;}
     }
     else if(cmd==='mobile')data=await mobileCommand(sub,rest,flags);
+    else if(cmd==='monitor'){data=await monitorCommand(sub,flags);if(!flags.json){console.log(renderMonitor(data));return;}}
     else if(['update','doctor','add'].includes(cmd)) {
       if(flags['dry-run']&&cmd!=='doctor')data={dryRun:true,command:parsed.args,action:cmd==='update'?'Check/install core version':'Write deployment configuration and install dependencies'};
       else {
@@ -126,7 +132,7 @@ export async function main() {
     }
     else if(cmd==='agent'&&sub==='init')data=await agentInit(flags);
     else if(cmd==='inspect') {
-      const p=await project();data={coreVersion:p.version,themeApiVersion:1,project:p.pkg.name,targets:{cloudflare:await exists('wrangler.jsonc')||await exists('wrangler.toml'),docker:await exists('Dockerfile')},themes:await listLocalThemes(p),capabilities:['theme-schema','theme-create','theme-check','theme-dev','theme-pack','scoped-design-api','editable-sections','section-library','section-types','page-presets','mobile-apps','mobile-editor-apps','mobile-recipes','mobile-docs','mobile-doctor'],mobileApps:await mobileApps(),configuration:await readJson(resolve(p.cwd,'.astro/acms-project.json')).catch(()=>({source:'Run astro sync or dev to discover configured collections.',collections:null}))};
+      const p=await project();data={coreVersion:p.version,themeApiVersion:1,project:p.pkg.name,targets:{cloudflare:await exists('wrangler.jsonc')||await exists('wrangler.toml'),docker:await exists('Dockerfile')},themes:await listLocalThemes(p),capabilities:['theme-schema','theme-create','theme-check','theme-dev','theme-pack','scoped-design-api','editable-sections','section-library','section-types','page-presets','mobile-apps','mobile-editor-apps','mobile-recipes','mobile-docs','mobile-doctor','monitor-kuma'],mobileApps:await mobileApps(),configuration:await readJson(resolve(p.cwd,'.astro/acms-project.json')).catch(()=>({source:'Run astro sync or dev to discover configured collections.',collections:null}))};
     } else if(cmd==='theme')data=await themeCommand(sub,rest,flags);
     else if(['site','design','content','media'].includes(cmd))data=await remoteCommand(cmd,sub,rest,flags);
     else fail('USAGE','Unknown command.',[],['Run acms --help']);

package/cli/mobile-doctor.mjs

@@ -208,6 +208,15 @@ async function doctorApp(app, flags, ctx) {
     else c.fail('site', 'Site API', `${url}/api/v1/site returned ${r.status}${r.json ? '' : ' (not the ACMS API)'}.`, { hint: 'Check EXPO_PUBLIC_ACMS_URL points at the site origin and the site runs @acms-subir/core with the mobile API.' });
   }
   const live = !!site;
+  // the site's own health (what Uptime Kuma watches): a warning, never a failure,
+  // since a local dev server usually has no scheduler running
+  if (live) {
+    const h = await getJson(`${url}/api/health`);
+    const bad = Object.entries(h.json?.checks ?? {}).filter(([, v]) => v !== 'ok' && v !== 'off').map(([k, v]) => `${k} ${v}`);
+    if (h.status === 200 && h.json?.status === 'ok') c.pass('health', 'Site health', 'Database, scheduler and email are working (/api/health).');
+    else if (h.status === 200 || h.status === 503) c.warn('health', 'Site health', `/api/health reports ${h.json?.status ?? 'down'}${bad.length ? `: ${bad.join(', ')}` : ''}.`, { hint: 'A stopped scheduler means no reminders, scheduled posts or emails: check the cron (Cloudflare) or the runner (Docker). Watch it with npx acms monitor kuma.' });
+    else c.warn('health', 'Site health', `/api/health returned ${h.status}.`, { hint: 'Update the site (npx acms update): older releases have no health check.' });
+  }
 
   // 6. app ids
   if (!appJson) c.fail('app-ids', 'App identity', 'app.json is missing or not valid JSON.', { hint: `Restore ${app.dir}/app.json (see the starter: npx acms add mobile --dry-run).` });

package/cli/monitor.mjs

@@ -0,0 +1,189 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomInt } from 'node:crypto';
+import { fail } from './common.mjs';
+import { listApps } from './mobile.mjs';
+
+// `acms monitor kuma`: puts a site's monitors into Uptime Kuma (website, app
+// API, staff app API, health, scheduler heartbeat) in one group, plus a
+// status page for Settings → Monitoring. Kuma has no REST API for this, so
+// it speaks Kuma's own dashboard protocol (Socket.IO over a WebSocket),
+// tested with Kuma 1.23 and 2.x. Running it again updates, never duplicates.
+// `--print` lists the same monitors to add by hand.
+// Login comes from KUMA_USERNAME / KUMA_PASSWORD (+ KUMA_TOTP for 2FA):
+// never arguments, never stored.
+
+const TIMEOUT = 15_000;
+
+/** the monitors for one site; `kuma` is the Kuma version major (1 or 2) */
+export function monitorPlan(site, opts = {}) {
+  const base = { method: 'GET', retryInterval: 60, resendInterval: 0, timeout: 30, ignoreTls: false, upsideDown: false, expiryNotification: false, maxredirects: 10, notificationIDList: {} };
+  const http = (name, path, extra = {}) => ({ ...base, type: 'http', name, url: `${site}${path}`, interval: 60, maxretries: 1, accepted_statuscodes: ['200-299'], ...extra });
+  const list = [
+    { key: 'website', what: 'The website answers', ...http('Website', '/') },
+    // the case to catch: the app API removed or broken (a 404 or a wrong answer)
+    { key: 'app-api', what: 'The app API answers as v1', ...http('App API', '/api/v1/site', { type: 'json-query', jsonPath: 'data.apiVersion', expectedValue: '1', ...(opts.kuma === 1 ? {} : { jsonPathOperator: '==' }) }) },
+    ...(opts.staff === false ? [] : [{ key: 'staff-api', what: 'The staff app API exists (401 = up)', ...http('Staff app API', '/api/v1/admin/me', { accepted_statuscodes: ['401'] }) }]),
+    { key: 'health', what: 'Database, scheduler and email (503 = down)', ...http('Health', '/api/health') },
+    { key: 'scheduler', what: 'The scheduler reported in the last 3 min', ...base, type: 'push', name: 'Scheduler', url: 'https://', interval: 180, maxretries: 0, accepted_statuscodes: ['200-299'], pushToken: opts.pushToken ?? token() },
+  ];
+  // Kuma 2 stores alert conditions; Kuma 1 refuses columns it doesn't have
+  return opts.kuma === 1 ? list : list.map((m) => ({ ...m, conditions: [] }));
+}
+function token(n = 32) {
+  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  return Array.from({ length: n }, () => chars[randomInt(chars.length)]).join('');
+}
+
+// ---- a minimal Socket.IO v4 client (WebSocket transport only) -----------------
+
+export function kumaSocket(base) {
+  const url = `${base.replace(/^http/, 'ws')}/socket.io/?EIO=4&transport=websocket`;
+  const ws = new WebSocket(url);
+  const acks = new Map(), latest = {};
+  let next = 0, closed = false;
+  const ready = new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error('timeout')), TIMEOUT);
+    ws.onerror = () => { clearTimeout(timer); reject(new Error('unreachable')); };
+    ws.onclose = () => { closed = true; for (const [, a] of acks) a.reject(new Error('closed')); acks.clear(); };
+    ws.onmessage = ({ data }) => {
+      const s = String(data);
+      if (s === '2') return ws.send('3'); // ping → pong
+      if (s.startsWith('0')) return ws.send('40'); // open → join the default namespace
+      if (s.startsWith('44')) { clearTimeout(timer); return reject(new Error('refused')); }
+      if (s.startsWith('40')) { clearTimeout(timer); return resolve(); }
+      const ack = /^43(\d+)([\s\S]*)$/.exec(s);
+      if (ack) { const a = acks.get(Number(ack[1])); acks.delete(Number(ack[1])); a?.resolve(JSON.parse(ack[2])[0]); return; }
+      if (s.startsWith('42')) { try { const [event, payload] = JSON.parse(s.slice(2)); latest[event] = payload; } catch { /* not ours */ } }
+    };
+  });
+  const call = (event, ...args) => new Promise((resolve, reject) => {
+    if (closed) return reject(new Error('closed'));
+    const id = next++;
+    const timer = setTimeout(() => { acks.delete(id); reject(new Error('timeout')); }, TIMEOUT);
+    acks.set(id, { resolve: (v) => { clearTimeout(timer); resolve(v); }, reject: (e) => { clearTimeout(timer); reject(e); } });
+    ws.send(`42${id}${JSON.stringify([event, ...args])}`);
+  });
+  /** waits until Kuma has pushed `event` (sent by the server after login), optionally one that passes `test` */
+  const wait = async (event, test = (v) => !!v, ms = 8000) => { for (let t = 0; t < ms && !test(latest[event]); t += 100) await new Promise((r) => setTimeout(r, 100)); return latest[event]; };
+  return { ready, call, wait, latest, close: () => { closed = true; ws.close(); } };
+}
+
+// ---- the command --------------------------------------------------------------
+
+function origin(raw, what) {
+  let u;
+  try { u = new URL(raw); } catch { fail('USAGE', `${what} must be an address like https://example.com.`); }
+  if (!['http:', 'https:'].includes(u.protocol) || u.username || u.password) fail('USAGE', `${what} must be an http(s) address without credentials.`);
+  return u.origin;
+}
+/** --url, else the site address baked into the mobile app (.env) */
+async function siteAddress(flags) {
+  if (flags.url) return origin(flags.url, '--url');
+  for (const app of await listApps().catch(() => [])) {
+    const env = await readFile(join(app.dir, '.env'), 'utf8').catch(() => '');
+    const v = env.match(/^EXPO_PUBLIC_ACMS_URL=(.*)$/m)?.[1]?.trim();
+    if (v && /^https:\/\//.test(v)) return origin(v, 'EXPO_PUBLIC_ACMS_URL');
+  }
+  fail('USAGE', 'Which site? Pass --url https://your-site.', [], ['acms monitor kuma --url https://your-site --kuma https://your-kuma']);
+}
+async function probe(url) {
+  try { const r = await fetch(url, { signal: AbortSignal.timeout(8000), headers: { accept: 'application/json' } }); return { status: r.status, json: await r.json().catch(() => null) }; }
+  catch { return { status: 0, json: null }; }
+}
+const slugFor = (host) => `acms-${host.replace(/[^a-z0-9]+/gi, '-').replace(/^-|-$/g, '').toLowerCase()}`.slice(0, 60);
+
+export async function monitorCommand(sub, flags) {
+  if (sub !== 'kuma') fail('USAGE', 'Use: acms monitor kuma --url https://your-site --kuma https://your-kuma [--print]');
+  const site = await siteAddress(flags);
+  const host = new URL(site).host;
+  // what the site has: staff app API (401) or not (404); the site name for labels
+  const [info, staff] = await Promise.all([probe(`${site}/api/v1/site`), probe(`${site}/api/v1/admin/me`)]);
+  const warnings = [];
+  if (info.status !== 200) warnings.push(`${site}/api/v1/site answered ${info.status || 'nothing'}: check the address (Kuma will show the App API as down until it answers).`);
+  const hasStaff = staff.status === 401;
+  if (!hasStaff) warnings.push('The staff app API isn’t on (no mobile.editor in the site config), so there is no Staff app API monitor.');
+  const group = info.json?.data?.name ? `${info.json.data.name} (${host})` : host;
+
+  const kumaRaw = flags.kuma ?? process.env.KUMA_URL;
+  if (flags.print || !kumaRaw) {
+    if (!flags.print) warnings.push('No --kuma address (or KUMA_URL): listing the monitors to add by hand.');
+    return { mode: 'print', site, group, monitors: monitorPlan(site, { staff: hasStaff }).map(view), warnings };
+  }
+  const kuma = origin(kumaRaw, '--kuma');
+  const username = process.env.KUMA_USERNAME, password = process.env.KUMA_PASSWORD;
+  if (!username || !password) fail('AUTH', 'Set KUMA_USERNAME and KUMA_PASSWORD (and KUMA_TOTP when Kuma uses two-factor sign-in).', [], ['read -rs KUMA_PASSWORD && export KUMA_PASSWORD   # keeps it out of shell history']);
+
+  const k = kumaSocket(kuma);
+  try {
+    try { await k.ready; } catch (e) { fail('NETWORK', `Couldn’t reach Uptime Kuma at ${kuma} (${e.message}).`, [], ['Check --kuma, or run with --print to add the monitors by hand.']); }
+    let login = await k.call('login', { username, password, token: process.env.KUMA_TOTP ?? '' });
+    if (login?.tokenRequired) fail('AUTH', 'Kuma asks for a two-factor code: set KUMA_TOTP to the current code and run again.');
+    if (!login?.ok) fail('AUTH', `Kuma refused the sign-in${login?.msg ? `: ${login.msg}` : ''}.`);
+    // the version only comes with the info Kuma sends after login
+    const info = await k.wait('info', (v) => !!v?.version);
+    const major = Number(String(info?.version ?? '2').split('.')[0]) || 2;
+    const existing = Object.values(await k.wait('monitorList') ?? {});
+    const ok = (r, what) => { if (!r?.ok) throw Object.assign(new Error(`${what}: ${r?.msg ?? 'no answer'}`), { kuma: true }); return r; };
+
+    // the group, then each monitor inside it (matched by name, so reruns update)
+    let parent = existing.find((m) => m.type === 'group' && m.name === group);
+    const results = [];
+    if (!parent) {
+      const { key: _k, what: _w, ...first } = monitorPlan(site, { kuma: major })[0];
+      const r = ok(await k.call('add', { ...first, type: 'group', name: group, url: 'https://', parent: null }), 'group');
+      parent = { id: r.monitorID };
+      results.push({ name: group, action: 'created', type: 'group' });
+    }
+    const children = existing.filter((m) => m.parent === parent.id);
+    const pushToken = children.find((m) => m.type === 'push' && m.name === 'Scheduler')?.pushToken;
+    const ids = [];
+    for (const { key: _k, what: _w, ...m } of monitorPlan(site, { kuma: major, staff: hasStaff, pushToken })) {
+      const old = children.find((c) => c.name === m.name);
+      const r = old
+        ? ok(await k.call('editMonitor', { ...old, ...m, id: old.id, parent: parent.id }), m.name)
+        : ok(await k.call('add', { ...m, parent: parent.id }), m.name);
+      ids.push(r.monitorID ?? old.id);
+      results.push({ name: m.name, action: old ? 'updated' : 'created', type: m.type, url: m.type === 'push' ? null : m.url });
+    }
+    const push = `${kuma}/api/push/${pushToken ?? (await k.call('getMonitor', ids[ids.length - 1]))?.monitor?.pushToken}`;
+
+    // a public status page with these monitors, for Settings → Monitoring
+    const slug = slugFor(host);
+    let page = await k.call('getStatusPage', slug);
+    if (!page?.ok) { ok(await k.call('addStatusPage', group, slug), 'status page'); page = await k.call('getStatusPage', slug); }
+    ok(page, 'status page');
+    ok(await k.call('saveStatusPage', slug, { ...page.config, title: group, published: true }, page.config.icon, [{ name: group, monitorList: ids.map((id) => ({ id })) }]), 'status page');
+
+    return { mode: 'kuma', site, kuma, kumaVersion: info?.version ?? null, group, monitors: results, pushUrl: push, statusPage: `${kuma}/status/${slug}`, warnings };
+  } catch (e) {
+    if (!e?.kuma) throw e;
+    // Kuma changed its dashboard protocol (or refused a field): fall back to the list
+    return { mode: 'print', site, group, monitors: monitorPlan(site, { staff: hasStaff }).map(view), warnings: [...warnings, `Kuma didn’t accept the setup (${e.message}). Add these by hand, or update ACMS.`] };
+  } finally { k.close(); }
+}
+
+const view = (m) => ({ name: m.name, type: m.type, url: m.type === 'push' ? null : m.url, interval: m.interval, check: m.what,
+  ...(m.jsonPath ? { jsonQuery: `${m.jsonPath} == ${m.expectedValue}` } : {}), acceptedStatusCodes: m.accepted_statuscodes, retries: m.maxretries });
+
+export function renderMonitor(d) {
+  const out = [];
+  for (const w of d.warnings) out.push(`! ${w}`);
+  if (d.mode === 'print') {
+    out.push(`Add these to Uptime Kuma in a group named "${d.group}":`, '');
+    for (const m of d.monitors) {
+      out.push(`  ${m.name}  (${m.type === 'json-query' ? 'HTTP(s) - Json Query' : m.type === 'push' ? 'Push' : 'HTTP(s)'}, every ${m.interval} s${m.retries ? `, ${m.retries} retry` : ''})`);
+      if (m.url) out.push(`    URL: ${m.url}`);
+      if (m.jsonQuery) out.push(`    Json Query: ${m.jsonQuery}`);
+      if (m.acceptedStatusCodes.join() !== '200-299') out.push(`    Accepted status codes: ${m.acceptedStatusCodes.join(', ')}`);
+      out.push(`    Checks: ${m.check}`);
+    }
+    out.push('', 'Then paste the Scheduler monitor’s push URL and a status page with these monitors into Admin → Settings → Monitoring.');
+    return out.join('\n');
+  }
+  out.push(`Uptime Kuma ${d.kumaVersion ?? ''} at ${d.kuma}: ${d.group}`);
+  for (const m of d.monitors) out.push(`  ✓ ${m.action.padEnd(7)} ${m.name}${m.url ? `  ${m.url}` : ''}`);
+  out.push('', 'Paste into Admin → Settings → Monitoring:', `  Scheduler heartbeat: ${d.pushUrl}`, `  Status page:         ${d.statusPage}`,
+    '', 'Alerts: in Kuma, add a notification (email, Telegram, Discord…) to the group’s monitors.');
+  return out.join('\n');
+}

package/docs/mobile.md

@@ -113,11 +113,15 @@ Read the app's `AGENTS.md` too: it holds the same rules, next to the code.
 
 | Hook | For |
 | --- | --- |
-| `useSite()` | name, menu, languages, features (`calendar`, `bookings`, `blog`) |
+| `useSite()` | name, menu, languages, features (`calendar`, `bookings`, `blog`, `search`, `bookingChanges`, `guestSignIn`, `forms`, `links`) |
 | `usePage(slug)` | a published page: `mode` (`sections`/`content`), `sections`, `body.html`; 404 when missing |
-| `usePosts({ collection, limit })` / `usePost(slug)` | posts (infinite: `items`, `fetchNextPage`) |
+| `usePosts({ collection, limit, q })` / `usePost(slug)` | posts (infinite: `items`, `fetchNextPage`); `q` gives ranked search matches |
+| `useSearch(text, { types, collection, limit })` | site-wide search: `data.posts`, `data.pages`, `data.events` (each with `snippet.text` + `snippet.highlights`), `data.more`; debounced, blank text fetches nothing |
 | `useEvents({ calendar, from, to, limit, q })` | `data.occurrences[]` (`start`, `end`, `allDay`, `event`) in a window (default 30 days, max 90). `from`/`to` take a site-local day (`'2026-10-01'`) or an ISO date-time with a zone (`new Date().toISOString()`) |
 | `useEvent(slug)` | one event |
+| `useManagedBooking(token)` / `useCancelBooking` / `useRescheduleBooking` / `useRescheduleAvailability` | the booker's own booking (from `book()`'s `manageToken`): `can.cancel`, `can.reschedule`, `can.closed` (change cutoff passed: show "Contact us") |
+| `useGuest()` / `useMyBookings({ when })` | guest sign-in with an emailed code, then every booking made with that email; check `features.guestSignIn` |
+| `useLinks()` / `useForm(id)` / `useSubmitForm(id)` | the links page; published forms and sending answers; check `features.links` / `features.forms` |
 | `useResources()` / `useAvailability({ resource, link })` / `useBooking()` | bookings |
 | `useLocale()`, `useTheme()`, `useLayout()`, `useRefresh()`, `useOpenLink()` | language, tokens, layout, refresh, links |
 | `usePushRegistration({ topics })` / `usePushTopics()` / `useNotificationTaps()` | push notifications (see Push notifications) |
@@ -228,6 +232,23 @@ choose the calendar, better still: they add an **Upcoming events** section
 (its events source has a calendar and a limit) to the home page in the admin,
 and `<Sections>` renders it with no app code at all. Say so in your summary.
 
+**Search one collection as people type.** Check `useSite().data?.features.search`
+first; when it is false, hide the field. Pass a debounced value to `usePosts`:
+
+```tsx
+const [text, setText] = useState('');
+const q = useDebounced(text);
+const sermons = usePosts({ collection: 'sermons', q });
+// <TextInput value={text} onChangeText={setText} />, then sermons.items;
+// q && !sermons.isFetching && !sermons.items.length → "No sermons match"
+```
+
+For a search screen across everything, `useSearch(text)` returns groups
+(posts, pages, events) with snippets. Group `posts` by `collection` for
+headings, and when `more.posts` is true link to the collection list with that
+`q`. Search matches the main-language text, so Spanish words find content only
+where the original is Spanish.
+
 **A native version of a coded section.** From the site folder:
 `npx acms section new visit-banner --theme <slug>` (new) or, for an existing
 coded section, write `mobile/sections/VisitBanner.tsx` typed with

package/integration.mjs

@@ -71,6 +71,8 @@ const ROUTES = [
   ['/api/email/webhooks/[provider]', 'api/email/webhooks/[provider].ts'],
   ['/api/email/run', 'api/email/run.ts'],
   ['/api/ops/status', 'api/ops/status.ts'],
+  ['/api/health', 'api/health.ts'],
+  ['/api/monitoring', 'api/monitoring.ts'],
   ['/admin/ai', 'admin/ai.astro'],
   ['/admin/import', 'admin/import.astro'],
   ['/admin/tags', 'admin/tags.astro'],
@@ -231,7 +233,7 @@ function resolveI18n(i18n, contentBases) {
 }
 
 // Defaults + validation for acms({ search }). Search ships on; disabling it
-// removes the /search page(s) and /api/search from the route table, and the
+// removes the /search page(s), /api/search and /api/v1/search from the route table, and the
 // layout skips the header trigger + modal (lib/search-config.ts).
 function resolveSearch(search) {
   if (search === undefined) return { enabled: true };
@@ -471,7 +473,8 @@ function acmsVitePlugin(userConfig) {
  *   browser (/admin/app-auth, OAuth 2.0 + PKCE; only the listed redirect URIs
  *   receive codes) and edit through the bearer-token /api/v1/admin/* API.
  * @param {{enabled?: boolean}} [options.search]
- *   Public site search: the /search page, the /api/search JSON endpoint, and
+ *   Public site search: the /search page, the /api/search JSON endpoint, app
+ *   search (/api/v1/search and /api/v1/content?q=), and
  *   the header search modal. On by default — set `enabled: false` to remove
  *   all three.
  * @param {false | {enabled?: boolean, base?: string, eventsBase?: string, defaultView?: 'month' | 'week' | 'list', eventFields?: Array<{key: string, label?: string, type?: 'text' | 'textarea' | 'number' | 'url' | 'select', options?: string[]}>}} [options.calendar]
@@ -532,6 +535,9 @@ export default function acms(options = {}) {
     ['/api/v1/openapi.json', 'api/v1/openapi.json.ts'],
     ['/api/v1/content', 'api/v1/content/index.ts'],
     ['/api/v1/content/[id]', 'api/v1/content/[id].ts'],
+    ['/api/v1/links', 'api/v1/links.ts'],
+    ['/api/v1/forms/[id]', 'api/v1/forms/[id]/index.ts'],
+    ['/api/v1/forms/[id]/responses', 'api/v1/forms/[id]/responses.ts'],
   ];
   if (mobile.ios) routes.push(['/.well-known/apple-app-site-association', '.well-known/apple-app-site-association.ts']);
   if (mobile.android) routes.push(['/.well-known/assetlinks.json', '.well-known/assetlinks.json.ts']);
@@ -541,9 +547,10 @@ export default function acms(options = {}) {
       ['/api/v1/devices/[token]', 'api/v1/devices/[token].ts'],
       ['/api/v1/push/topics', 'api/v1/push/topics.ts'],
       ['/api/push/admin', 'api/push/admin.ts'],
-      ['/admin/mobile', 'admin/mobile.astro'],
     );
   }
+  // Admin → Mobile app: app access switches always; notifications when push is on
+  routes.push(['/admin/mobile', 'admin/mobile.astro'], ['/api/mobile/access', 'api/mobile/access.ts']);
   if (mobile.editor.enabled) {
     // editor apps: browser sign-in (OAuth 2.0 + PKCE) and the bearer-only admin API
     routes.push(
@@ -564,6 +571,19 @@ export default function acms(options = {}) {
       ['/api/v1/admin/media', 'api/v1/admin/media/index.ts'],
       ['/api/v1/admin/bookings', 'api/v1/admin/bookings/index.ts'],
       ['/api/v1/admin/bookings/[id]/[action]', 'api/v1/admin/bookings/[id]/[action].ts'],
+      // schedule + setup (calendar/booking handlers answer 404 when those modules are off)
+      ['/api/v1/admin/schedule', 'api/v1/admin/schedule.ts'],
+      ['/api/v1/admin/resources', 'api/v1/admin/resources/index.ts'],
+      ['/api/v1/admin/resources/[id]', 'api/v1/admin/resources/[id]/index.ts'],
+      ['/api/v1/admin/resources/[id]/links', 'api/v1/admin/resources/[id]/links/index.ts'],
+      ['/api/v1/admin/resources/[id]/links/[linkId]', 'api/v1/admin/resources/[id]/links/[linkId].ts'],
+      ['/api/v1/admin/resources/[id]/blocks', 'api/v1/admin/resources/[id]/blocks/index.ts'],
+      ['/api/v1/admin/resources/[id]/blocks/[blockId]', 'api/v1/admin/resources/[id]/blocks/[blockId].ts'],
+      ['/api/v1/admin/calendars', 'api/v1/admin/calendars/index.ts'],
+      ['/api/v1/admin/calendars/[id]', 'api/v1/admin/calendars/[id].ts'],
+      ['/api/v1/admin/forms', 'api/v1/admin/forms/index.ts'],
+      ['/api/v1/admin/forms/[id]/responses', 'api/v1/admin/forms/[id]/responses.ts'],
+      ['/api/v1/admin/links', 'api/v1/admin/links.ts'],
     );
   }
   if (legal.enabled) routes.push(['/privacy', 'legal/privacy.astro'], ['/terms', 'legal/terms.astro']);
@@ -577,7 +597,7 @@ export default function acms(options = {}) {
     if (l !== i18n.defaultLocale) routes.push([`/${l}`, 'index.astro']);
   }
   if (search.enabled) {
-    routes.push(['/search', 'search.astro'], ['/api/search', 'api/search.ts']);
+    routes.push(['/search', 'search.astro'], ['/api/search', 'api/search.ts'], ['/api/v1/search', 'api/v1/search.ts']);
     // a locale-prefixed search page per non-default locale, mirroring the
     // per-locale home routes; search.astro derives its locale from the path
     for (const l of i18n.locales) {
@@ -604,6 +624,17 @@ export default function acms(options = {}) {
       ['/admin/calendar/integrations', 'admin/calendar/integrations.astro'],
       ['/api/calendar/docs', 'api/calendar/docs.ts'],
       [`${calendar.bookBase}/manage/[token]`, 'book/manage/[token].astro'],
+      // the booker's own booking from an app (token in the Booking-Token header)
+      ['/api/v1/bookings/manage', 'api/v1/bookings/manage/index.ts'],
+      ['/api/v1/bookings/manage/cancel', 'api/v1/bookings/manage/cancel.ts'],
+      ['/api/v1/bookings/manage/availability', 'api/v1/bookings/manage/availability.ts'],
+      ['/api/v1/bookings/manage/reschedule', 'api/v1/bookings/manage/reschedule.ts'],
+      ['/api/v1/bookings/manage/ics', 'api/v1/bookings/manage/ics.ts'],
+      // guest sign-in for "My bookings" (answers 404 until email is set up)
+      ['/api/v1/guest/code', 'api/v1/guest/code.ts'],
+      ['/api/v1/guest/token', 'api/v1/guest/token.ts'],
+      ['/api/v1/guest/bookings', 'api/v1/guest/bookings.ts'],
+      ['/api/v1/guest/revoke', 'api/v1/guest/revoke.ts'],
       ['/admin/calendar/bookings', 'admin/calendar/bookings.astro'],
     );
     if (calendar.bookings) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acms-subir/core",
-  "version": "0.3.9",
+  "version": "0.3.10",
   "publishConfig": {
     "access": "public"
   },

package/src/actions/index.ts

@@ -14,13 +14,14 @@ import { CONTENT, collectionUrl } from '../lib/content';
 import { invalidateRedirectCache } from '../middleware';
 import { isPrivateHost } from '../lib/net';
 import { normalizeCalendarSrc } from '../lib/calendar/src';
+import { saveCalendar } from '../lib/calendar/admin';
 import { getCalendarEvents } from '../lib/calendar/ics';
 import { siteLocale } from '../lib/dates';
 import { normalizePageLocale, localeHomeUrl } from '../lib/i18n';
 import { CALENDAR, bookingsEnabled } from '../lib/calendar/config';
 import { holdConflicts } from '../lib/booking/holds';
 import { setBookingStatus } from '../lib/booking/service';
-import { eventTimeZone, featuredOccurrence, formatOccurrence, isValidTimeZone, normalizeEventTimes, safeColor } from '../lib/calendar/events';
+import { eventTimeZone, featuredOccurrence, formatOccurrence, isValidTimeZone, normalizeEventTimes } from '../lib/calendar/events';
 import { eventsFromCsv, eventsFromIcs, eventsFromVEvents } from '../lib/calendar/import';
 import { loadFeed } from '../lib/calendar/ics';
 import { NATIVE_ALL } from '../lib/calendar/render';
@@ -1212,32 +1213,11 @@ export const server = {
       handler: async ({ id, ...data }, ctx) => {
         await requireAdmin(ctx);
         const repo = await getRepo(ctx.locals);
-        const existing = id ? await repo.getCalendar(id) : null;
-        if (id && !existing) throw new ActionError({ code: 'NOT_FOUND', message: 'Calendar not found.' });
-        const kind = existing?.kind ?? data.kind ?? 'native';
-        let feedUrl = existing?.feedUrl ?? '';
-        if (kind === 'feed' && (data.feedUrl !== undefined || !existing)) {
-          const normalized = normalizeCalendarSrc(data.feedUrl ?? '');
-          if (!normalized) throw new ActionError({ code: 'BAD_REQUEST', message: 'Paste a Google Calendar link, a calendar ID, or an .ics feed URL.' });
-          feedUrl = normalized;
+        try { return { calendar: await saveCalendar(repo, id, data) }; }
+        catch (e) {
+          if (e instanceof ApiError) throw new ActionError({ code: e.status === 404 ? 'NOT_FOUND' : 'BAD_REQUEST', message: e.message });
+          throw e;
         }
-        const base = slugify(data.slug || data.name);
-        let slug = base;
-        for (let n = 2; ; n++) {
-          const clash = await repo.getCalendarBySlug(slug);
-          if (!clash || clash.id === id) break;
-          slug = `${base}-${n}`;
-        }
-        const fields = {
-          name: data.name, slug, color: safeColor(data.color ?? existing?.color ?? '#4f46e5'),
-          description: data.description ?? existing?.description ?? '', feedUrl,
-          visibility: data.visibility ?? existing?.visibility ?? 'public',
-        };
-        if (existing) {
-          await repo.updateCalendar(existing.id, fields);
-          return { calendar: (await repo.getCalendar(existing.id))! };
-        }
-        return { calendar: await repo.createCalendar({ ...fields, kind }) };
       },
     }),
     reorder: defineAction({