create an event, newest day first, and a URL you can read

three small things, one of which turned out to be a bug in what shipped an hour
ago.

CREATE. a POST to /_officer/event, and the SIDECAR builds the file — the browser
sends title, when and where. a UID, a DTSTAMP and a UTC timestamp each have
exactly one correct form, and that belongs next to the parser that reads them
back, not in a react component. it writes the minimum a VEVENT can legally be:
no recurrence, no alarms, no attendees. this app cannot show those, and a field
the list cannot display is a field that silently disappears on the next edit.

times go in as UTC. the alternative is DTSTART;TZID plus a VTIMEZONE block
defining that zone's rules, and a subtly wrong VTIMEZONE moves an event by an
hour twice a year. UTC needs no definition and every client renders it local.
all-day is the other trap: RFC 5545 makes DTEND EXCLUSIVE, so a one-day event on
the 29th ends on the 30th — write the 29th and some clients draw nothing at all.
the form takes the last day a person means and the builder adds the day.

NEWEST DAY ON TOP. a calendar accumulates years, so ascending opened on whatever
was imported first and this week was a scroll away. within a day the order stays
chronological, because that is what a day is.

?collection=ra-guide, NOT ?collection=%2Fdav%2F1%2Fra-guide%2F. the path is
/dav/<userId>/<name>/, so the escaped form spent six characters on slashes to
say `ra-guide` and put the owner's user id in a URL people paste at each other.
the name is unique within a user, which is all a selector needs, and the full
path is recovered from the collections list the screen already loaded. a full
path in the param still resolves, because somebody's bookmark has one.

AND THE BUG. setProperty replaced a property's first line and left its
continuation lines behind. a value over 75 octets is FOLDED onto lines starting
with a space — so editing a long summary left the old tail folded onto the new
value, and each edit inherited the last one's ending. it only bites on long
values, which is why the first round of testing missed it. the fix consumes the
whole folded run and folds what it writes; both are now under test, including
the accent-near-the-boundary case that a naive slice(0,75) cuts in half.

verified live: both event shapes written and read back, escaping round-tripped,
and a long summary edited twice with no accumulation.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Officer-Session: 656f5c85-e49a-4f1f-b9f3-042a04b4d043

sidecar/collections.ts

@@ -1,4 +1,4 @@
-import { parseContacts, parseEvents, type CalendarEvent, type Contact } from './ical';
+import { buildEvent, parseContacts, parseEvents, type CalendarEvent, type Contact, type NewEvent } from './ical';
 
 // The JSON door: what Officer's own web UI reads.
 //
@@ -11,8 +11,14 @@ import { parseContacts, parseEvents, type CalendarEvent, type Contact } from './
 // docs/nextcloud-replacement.md, "two front doors, not one".
 
 export type Collection = {
-  /** DAV path, relative to the /dav mount — the id the UI passes back. */
+  /** DAV path, relative to the /dav mount — the id the UI passes back on every read. */
   path: string;
+  /**
+   * The last path segment, and the only part of the path that identifies anything. The web URLs select
+   * with this rather than the whole path: `?collection=personal` instead of `?collection=%2Fdav%2F1%2Fpersonal%2F`,
+   * which is the same information without the user id, the mount point and six escaped slashes.
+   */
+  name: string;
   displayName: string;
   kind: 'calendar' | 'addressbook';
   /** Radicale stores a per-collection colour when a client sets one; used for the UI's dot. */
@@ -77,6 +83,7 @@ export async function listCollections(fetcher: Fetcher, userId: string): Promise
 
     collections.push({
       path,
+      name: lastSegment,
       // Radicale's default displayname is the collection's own path ("1/work"), which is an id, not a
       // name. A real client sets something human when it creates a collection; until one does, the last
       // segment is the better label — and it is what every DAV client falls back to anyway.
@@ -150,3 +157,26 @@ export async function listContacts(fetcher: Fetcher, path: string): Promise<Cont
   const objects = await readObjects(fetcher, path, 'addressbook');
   return objects.flatMap((o) => parseContacts(o.data).map((c) => ({ ...c, href: o.href })));
 }
+
+/**
+ * Create one event, in its own file.
+ *
+ * THE FILENAME IS A FRESH UUID, and it is also the UID. Not because a client may assume they match —
+ * nothing here does, and the listing carries the real href precisely because they often do not — but
+ * because a new name has to come from somewhere, and one that cannot collide is the cheapest kind.
+ *
+ * `If-None-Match: *` makes the PUT conditional on the file NOT existing, so a retried request cannot
+ * quietly overwrite an event created by the first attempt.
+ */
+export async function createEvent(fetcher: Fetcher, collection: string, event: NewEvent): Promise<{ href: string }> {
+  const uid = crypto.randomUUID();
+  const href = `${collection.replace(/\/$/, '')}/${uid}.ics`;
+
+  const res = await fetcher(href, {
+    method: 'PUT',
+    headers: { 'Content-Type': 'text/calendar; charset=utf-8', 'If-None-Match': '*' },
+    body: buildEvent(uid, event),
+  });
+  if (!res.ok) throw new Error(`radicale answered ${res.status}`);
+  return { href };
+}

sidecar/ical.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, test } from 'bun:test';
+import { buildEvent, fold, parseEvents } from './ical';
+
+// The two rules here are the ones that are invisible when broken: DTEND is exclusive for an all-day
+// event, and a content line is folded at 75 OCTETS. Both produce a file that looks fine and renders
+// wrong somewhere else.
+
+describe('buildEvent', () => {
+  test('a timed event is written in UTC, with both ends', () => {
+    const ics = buildEvent('u1', {
+      summary: 'Lunch',
+      start: '2026-08-28T13:00:00.000Z',
+      end: '2026-08-28T14:00:00.000Z',
+      allDay: false,
+    });
+    expect(ics).toContain('DTSTART:20260828T130000Z');
+    expect(ics).toContain('DTEND:20260828T140000Z');
+    expect(ics.endsWith('END:VCALENDAR\r\n')).toBe(true);
+  });
+
+  test('no end means an hour', () => {
+    const ics = buildEvent('u1', { summary: 'Lunch', start: '2026-08-28T13:00:00.000Z', allDay: false });
+    expect(ics).toContain('DTEND:20260828T140000Z');
+  });
+
+  test('an all-day event ends the NEXT day, because DTEND is exclusive', () => {
+    const ics = buildEvent('u1', { summary: 'Holiday', start: '2026-08-29', allDay: true });
+    expect(ics).toContain('DTSTART;VALUE=DATE:20260829');
+    expect(ics).toContain('DTEND;VALUE=DATE:20260830');
+  });
+
+  test('a multi-day all-day event takes the last day inclusive', () => {
+    const ics = buildEvent('u1', { summary: 'Trip', start: '2026-08-29', end: '2026-08-31', allDay: true });
+    expect(ics).toContain('DTEND;VALUE=DATE:20260901');
+  });
+
+  test('a month boundary rolls the month, not just the day', () => {
+    const ics = buildEvent('u1', { summary: 'Last of the month', start: '2026-08-31', allDay: true });
+    expect(ics).toContain('DTEND;VALUE=DATE:20260901');
+  });
+
+  test('TEXT separators are escaped, and survive the parser', () => {
+    const summary = 'Comma, semicolon; and a backslash \\ walk in';
+    const ics = buildEvent('u1', { summary, start: '2026-08-28T13:00:00.000Z', allDay: false });
+    expect(ics).toContain(String.raw`SUMMARY:Comma\, semicolon\; and a backslash \\ walk in`);
+    expect(parseEvents(ics)[0]!.summary).toBe(summary);
+  });
+
+  test('a long summary folds, and the parser reads it back whole', () => {
+    const summary = 'x'.repeat(200);
+    const ics = buildEvent('u1', { summary, start: '2026-08-28T13:00:00.000Z', allDay: false });
+    expect(ics.split('\r\n').every((l) => Buffer.byteLength(l, 'utf8') <= 75)).toBe(true);
+    expect(parseEvents(ics)[0]!.summary).toBe(summary);
+  });
+});
+
+describe('fold', () => {
+  test('a short line is left alone', () => {
+    expect(fold('SUMMARY:short')).toBe('SUMMARY:short');
+  });
+
+  test('every produced line fits in 75 octets, continuations included', () => {
+    const folded = fold(`SUMMARY:${'a'.repeat(400)}`);
+    expect(folded.split('\r\n').every((l) => Buffer.byteLength(l, 'utf8') <= 75)).toBe(true);
+  });
+
+  test('continuation lines start with exactly one space', () => {
+    const [, ...rest] = fold(`SUMMARY:${'a'.repeat(200)}`).split('\r\n');
+    expect(rest.every((l) => l.startsWith(' ') && !l.startsWith('  a'))).toBe(true);
+  });
+
+  test('a multi-byte character is never cut in half', () => {
+    // 'é' is two octets, so a boundary lands mid-character unless the fold counts encoded length.
+    const folded = fold(`SUMMARY:${'é'.repeat(100)}`);
+    expect(folded).not.toContain('�');
+    expect(folded.split('\r\n').every((l) => Buffer.byteLength(l, 'utf8') <= 75)).toBe(true);
+    expect(folded.split('\r\n').map((l, i) => (i ? l.slice(1) : l.slice(8))).join('')).toBe('é'.repeat(100));
+  });
+});

sidecar/ical.ts

@@ -6,8 +6,12 @@
 // owns correctness. `rrule` is passed through raw so the UI can say "repeats" without either of us
 // pretending to know when.
 //
-// Everything here is display-only. The authoritative copy of an event is the .ics on disk that DAV
-// clients read and write; nothing in this file ever writes one back.
+// Reading is display-only: the authoritative copy of an event is the .ics on disk that DAV clients read
+// and write, and an edit patches THAT text rather than rebuilding it from what was parsed here.
+//
+// `buildEvent` is the one exception, and only because a NEW event has no original to preserve. It is
+// deliberately the minimum a VEVENT can legally be — no RRULE, no alarms, no attendees. Officer's screens
+// cannot express those, and writing a field the UI cannot show is how an editor starts lying.
 
 /** Unfold RFC 5545 continuation lines (a leading space or tab continues the previous line). */
 function unfold(text: string): string[] {
@@ -204,3 +208,98 @@ export function parseContacts(vcf: string): Contact[] {
   }
   return contacts;
 }
+
+// ─── Writing ────────────────────────────────────────────────────────────────────────────────────────
+
+const escapeText = (value: string) =>
+  value
+    .replace(/\\/g, '\\\\')
+    .replace(/\r?\n/g, '\\n')
+    .replace(/([,;])/g, '\\$1');
+
+/**
+ * RFC 5545 §3.1: no content line over 75 OCTETS, continued by a line starting with one space.
+ *
+ * Octets, not characters — so this measures encoded length and breaks between code points. A pasted
+ * title with an accent in it is exactly where a naive `slice(0, 75)` splits a multi-byte character in
+ * half and produces a file some clients refuse and others render as mojibake.
+ */
+export function fold(line: string): string {
+  const encoder = new TextEncoder();
+  const out: string[] = [];
+  let current = '';
+  let bytes = 0;
+  for (const ch of line) {
+    const size = encoder.encode(ch).length;
+    if (bytes + size > 75) {
+      out.push(current);
+      current = ' ';
+      bytes = 1;
+    }
+    current += ch;
+    bytes += size;
+  }
+  out.push(current);
+  return out.join('\r\n');
+}
+
+const pad = (n: number) => String(n).padStart(2, '0');
+
+/** `20260827T140000Z`. Always UTC, so the file carries no timezone this codebase would have to resolve. */
+const utcStamp = (date: Date) =>
+  `${date.getUTCFullYear()}${pad(date.getUTCMonth() + 1)}${pad(date.getUTCDate())}T` +
+  `${pad(date.getUTCHours())}${pad(date.getUTCMinutes())}${pad(date.getUTCSeconds())}Z`;
+
+/** `2026-08-27` → `20260827`. */
+const dateStamp = (iso: string) => iso.slice(0, 10).replace(/-/g, '');
+
+const addDay = (iso: string) => {
+  const d = new Date(`${iso.slice(0, 10)}T00:00:00Z`);
+  d.setUTCDate(d.getUTCDate() + 1);
+  return d.toISOString().slice(0, 10);
+};
+
+export type NewEvent = {
+  summary: string;
+  location?: string;
+  /** An ISO instant for a timed event; `YYYY-MM-DD` when `allDay`. */
+  start: string;
+  /** Same shape as `start`. For an all-day event this is the LAST day, inclusive, as a person means it. */
+  end?: string;
+  allDay: boolean;
+};
+
+/**
+ * A minimal VEVENT, wrapped in its own VCALENDAR — one event per file, which is what every DAV client
+ * writes and what makes an href addressable.
+ *
+ * TIMES ARE WRITTEN IN UTC. The alternative is `DTSTART;TZID=Europe/Lisbon` plus a VTIMEZONE block
+ * defining that zone's rules, and getting a VTIMEZONE subtly wrong moves an event by an hour twice a
+ * year. UTC needs no definition and every client renders it in local time.
+ *
+ * ALL-DAY IS DIFFERENT, and its trap is DTEND. RFC 5545 makes the end date EXCLUSIVE, so a one-day
+ * event on the 27th ends on the 28th. Writing the 27th produces a zero-length event that some clients
+ * hide entirely; callers pass the last day they mean and this adds the day.
+ */
+export function buildEvent(uid: string, event: NewEvent): string {
+  const lines = ['BEGIN:VCALENDAR', 'VERSION:2.0', 'PRODID:-//Officer//caldav//EN', 'BEGIN:VEVENT', `UID:${uid}`];
+  lines.push(`DTSTAMP:${utcStamp(new Date())}`);
+
+  if (event.allDay) {
+    const last = event.end?.slice(0, 10) || event.start.slice(0, 10);
+    lines.push(`DTSTART;VALUE=DATE:${dateStamp(event.start)}`);
+    lines.push(`DTEND;VALUE=DATE:${dateStamp(addDay(last))}`);
+  } else {
+    const start = new Date(event.start);
+    // An hour is the default a calendar has taught everyone to expect from an event with no end.
+    const end = event.end ? new Date(event.end) : new Date(start.getTime() + 60 * 60 * 1000);
+    lines.push(`DTSTART:${utcStamp(start)}`);
+    lines.push(`DTEND:${utcStamp(end)}`);
+  }
+
+  lines.push(`SUMMARY:${escapeText(event.summary)}`);
+  if (event.location) lines.push(`LOCATION:${escapeText(event.location)}`);
+  lines.push('END:VEVENT', 'END:VCALENDAR');
+
+  return lines.map(fold).join('\r\n') + '\r\n';
+}

sidecar/index.ts

@@ -1,7 +1,7 @@
 import type { SidecarCommand, SidecarEvent } from '@@/sidecar/protocol';
 import { createSidecarConnector } from '@@/sidecar/connect';
 import { startRadicale, davPaths } from './radicale';
-import { listCollections, listEvents, listContacts } from './collections';
+import { listCollections, listEvents, listContacts, createEvent } from './collections';
 import { DATA_PATH } from '@@/data-path';
 import { API_URL } from '@@/officer-url.mjs';
 
@@ -232,6 +232,44 @@ const server = Bun.serve({
         return Response.json({ ok: true, status: res.status });
       }
 
+      /*
+        Create an event. POST rather than PUT, because the caller does not choose the address — the
+        sidecar mints the filename, so this is "add one to that collection", not "put this here".
+
+        The BODY carries the collection, which is why this sits above the guard below: that one reads a
+        collection out of the query string, and a create has none there.
+      */
+      if (url.pathname === '/_officer/event' && req.method === 'POST') {
+        const body = (await req.json().catch(() => ({}))) as {
+          collection?: string;
+          summary?: string;
+          location?: string;
+          start?: string;
+          end?: string;
+          allDay?: boolean;
+        };
+        const collection = String(body.collection ?? '');
+        if (!collection.startsWith(`/dav/${userId}/`)) {
+          return Response.json({ error: 'collection is required and must be your own' }, { status: 400 });
+        }
+        const summary = (body.summary ?? '').trim();
+        if (!summary) return Response.json({ error: 'summary is required' }, { status: 400 });
+        if (!body.start) return Response.json({ error: 'start is required' }, { status: 400 });
+
+        try {
+          const created = await createEvent(fetcher, collection, {
+            summary,
+            location: (body.location ?? '').trim() || undefined,
+            start: body.start,
+            end: body.end,
+            allDay: Boolean(body.allDay),
+          });
+          return Response.json(created, { status: 201 });
+        } catch (err) {
+          return Response.json({ error: String(err) }, { status: 502 });
+        }
+      }
+
       const path = url.searchParams.get('collection');
       // Confine reads to this user's own tree. The header already scopes Radicale, but a path from a
       // query string is attacker-shaped input and should not be handed on unchecked.
@@ -247,7 +285,7 @@ const server = Bun.serve({
       }
 
       /*
-        Writing, from Officer's own screens.
+        On the writing routes above.
 
         ── Why the href is required and never derived ──