soja-cli 1.4.0

package/dist/data/local/tasks.js

@@ -0,0 +1,104 @@
+import { randomUUID } from 'node:crypto';
+import { and, count, desc, eq, inArray, isNotNull, isNull, or, sql } from 'drizzle-orm';
+import { taskActivity, taskComments, tasks, workspaces } from '../../database/schema.js';
+import { NotFoundError } from '../../domain/errors.js';
+import { must } from './users.js';
+export class LocalTaskRepository {
+    db;
+    clock;
+    constructor(db, clock) {
+        this.db = db;
+        this.clock = clock;
+    }
+    async create(input) {
+        const now = this.clock();
+        // Computing the number inside the INSERT keeps it atomic in SQLite.
+        // Provisional (negative) numbers never count towards the next real one, and
+        // numbers of deleted tasks are never handed out again.
+        const nextNumber = sql `(SELECT MAX(COALESCE(MAX(${tasks.number}), 0), COALESCE((SELECT ${workspaces.lastDeletedNumber} FROM ${workspaces} WHERE ${workspaces.id} = ${input.workspaceId}), 0)) + 1 FROM ${tasks} WHERE ${tasks.workspaceId} = ${input.workspaceId})`;
+        const [task] = await this.db
+            .insert(tasks)
+            .values({
+            startedAt: null,
+            completedAt: null,
+            archivedAt: null,
+            ...input,
+            id: input.id ?? randomUUID(),
+            number: input.number ?? nextNumber,
+            createdAt: now,
+            updatedAt: now,
+        })
+            .returning();
+        return must(task);
+    }
+    async findById(id) {
+        return (await this.db.select().from(tasks).where(eq(tasks.id, id)).get()) ?? null;
+    }
+    async findByNumber(workspaceId, number) {
+        const row = await this.db
+            .select()
+            .from(tasks)
+            .where(and(eq(tasks.workspaceId, workspaceId), eq(tasks.number, number)))
+            .get();
+        return row ?? null;
+    }
+    async list(query) {
+        const conditions = [eq(tasks.workspaceId, query.workspaceId)];
+        if (query.assigneeId)
+            conditions.push(eq(tasks.assigneeId, query.assigneeId));
+        if (query.projectId)
+            conditions.push(eq(tasks.projectId, query.projectId));
+        if (query.statuses)
+            conditions.push(inArray(tasks.status, [...query.statuses]));
+        const archived = query.archived ?? 'exclude';
+        if (archived === 'exclude')
+            conditions.push(isNull(tasks.archivedAt));
+        else if (archived === 'only')
+            conditions.push(isNotNull(tasks.archivedAt));
+        if (query.search) {
+            const pattern = `%${escapeLike(query.search.text)}%`;
+            const byTitle = sql `${tasks.title} LIKE ${pattern} ESCAPE '\\'`;
+            const byNumber = query.search.number === null ? undefined : eq(tasks.number, query.search.number);
+            conditions.push(or(byTitle, byNumber) ?? byTitle);
+        }
+        const statement = this.db
+            .select()
+            .from(tasks)
+            .where(and(...conditions))
+            .orderBy(desc(tasks.number));
+        return query.limit ? statement.limit(query.limit) : statement;
+    }
+    async update(id, patch) {
+        const [task] = await this.db
+            .update(tasks)
+            .set({ ...patch, updatedAt: this.clock() })
+            .where(eq(tasks.id, id))
+            .returning();
+        if (!task)
+            throw new NotFoundError('That task no longer exists.');
+        return task;
+    }
+    async countByProjectAndStatus(workspaceId) {
+        return this.db
+            .select({ projectId: tasks.projectId, status: tasks.status, count: count() })
+            .from(tasks)
+            .where(and(eq(tasks.workspaceId, workspaceId), isNull(tasks.archivedAt)))
+            .groupBy(tasks.projectId, tasks.status);
+    }
+    async delete(id) {
+        const task = await this.findById(id);
+        if (task && task.number > 0) {
+            await this.db
+                .update(workspaces)
+                .set({ lastDeletedNumber: sql `MAX(${workspaces.lastDeletedNumber}, ${task.number})` })
+                .where(eq(workspaces.id, task.workspaceId));
+        }
+        // Explicit, not only ON DELETE CASCADE: the remote replica runs without foreign keys.
+        await this.db.delete(taskActivity).where(eq(taskActivity.taskId, id));
+        await this.db.delete(taskComments).where(eq(taskComments.taskId, id));
+        await this.db.delete(tasks).where(eq(tasks.id, id));
+    }
+}
+function escapeLike(value) {
+    return value.replace(/[\\%_]/g, (char) => `\\${char}`);
+}

package/dist/data/local/users.js

@@ -0,0 +1,38 @@
+import { randomUUID } from 'node:crypto';
+import { eq, inArray } from 'drizzle-orm';
+import { users } from '../../database/schema.js';
+export class LocalUserRepository {
+    db;
+    clock;
+    constructor(db, clock) {
+        this.db = db;
+        this.clock = clock;
+    }
+    async findById(id) {
+        return (await this.db.select().from(users).where(eq(users.id, id)).get()) ?? null;
+    }
+    async findByUsername(username) {
+        return (await this.db.select().from(users).where(eq(users.username, username)).get()) ?? null;
+    }
+    async findByIds(ids) {
+        if (ids.length === 0)
+            return [];
+        return this.db
+            .select()
+            .from(users)
+            .where(inArray(users.id, [...ids]));
+    }
+    async create(input) {
+        const now = this.clock();
+        const [user] = await this.db
+            .insert(users)
+            .values({ id: randomUUID(), email: null, ...input, createdAt: now, updatedAt: now })
+            .returning();
+        return must(user);
+    }
+}
+export function must(row) {
+    if (row === undefined)
+        throw new Error('Expected the database to return a row');
+    return row;
+}

package/dist/data/local/workspaces.js

@@ -0,0 +1,55 @@
+import { randomUUID } from 'node:crypto';
+import { and, asc, eq } from 'drizzle-orm';
+import { users, workspaceMembers, workspaces } from '../../database/schema.js';
+import { must } from './users.js';
+export class LocalWorkspaceRepository {
+    db;
+    clock;
+    constructor(db, clock) {
+        this.db = db;
+        this.clock = clock;
+    }
+    async findById(id) {
+        return (await this.db.select().from(workspaces).where(eq(workspaces.id, id)).get()) ?? null;
+    }
+    async findBySlug(slug) {
+        return (await this.db.select().from(workspaces).where(eq(workspaces.slug, slug)).get()) ?? null;
+    }
+    async create(input) {
+        const now = this.clock();
+        const [workspace] = await this.db
+            .insert(workspaces)
+            .values({ id: randomUUID(), description: null, ...input, createdAt: now, updatedAt: now })
+            .returning();
+        return must(workspace);
+    }
+    async listForUser(userId) {
+        const rows = await this.db
+            .select({ workspace: workspaces, role: workspaceMembers.role })
+            .from(workspaceMembers)
+            .innerJoin(workspaces, eq(workspaces.id, workspaceMembers.workspaceId))
+            .where(eq(workspaceMembers.userId, userId))
+            .orderBy(asc(workspaces.name));
+        return rows.map((row) => ({ ...row.workspace, role: row.role }));
+    }
+    async addMember(member) {
+        await this.db.insert(workspaceMembers).values(member);
+    }
+    async findMember(workspaceId, userId) {
+        const row = await this.db
+            .select()
+            .from(workspaceMembers)
+            .where(and(eq(workspaceMembers.workspaceId, workspaceId), eq(workspaceMembers.userId, userId)))
+            .get();
+        return row ?? null;
+    }
+    async listMembers(workspaceId) {
+        const rows = await this.db
+            .select({ user: users, role: workspaceMembers.role })
+            .from(workspaceMembers)
+            .innerJoin(users, eq(users.id, workspaceMembers.userId))
+            .where(eq(workspaceMembers.workspaceId, workspaceId))
+            .orderBy(asc(users.username));
+        return rows.map((row) => ({ ...row.user, role: row.role }));
+    }
+}

package/dist/data/remote/api-client.js

@@ -0,0 +1,103 @@
+import { ConflictError, NotFoundError, SojaError, ValidationError } from '../../domain/errors.js';
+import { isSecureServerUrl } from '../../config/server.js';
+import { terminalSafe } from '../../utils/text.js';
+/** The server could not be reached at all (as opposed to answering with an error). */
+export class OfflineError extends SojaError {
+}
+/** The server rejected the session token. */
+export class SessionExpiredError extends SojaError {
+}
+/** `…At` fields arrive as ISO strings; the rest of SOJA works with Dates. */
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+/**
+ * Every string from the server is made terminal-safe here, the single door
+ * remote data comes through (other people's titles, comments, names…), and
+ * `…At` fields become Dates.
+ */
+function reviveDates(key, value) {
+    if (typeof value !== 'string')
+        return value;
+    if (key.endsWith('At') && ISO_DATE.test(value))
+        return new Date(value);
+    return terminalSafe(value);
+}
+/** Parses JSON from the server the same way the HTTP client does (safe text, Dates). */
+export function parseServerJson(text) {
+    return JSON.parse(text, reviveDates);
+}
+/**
+ * JSON over HTTPS to a SOJA server. Server errors become the same error
+ * classes local mode throws, so the interface shows them the same way.
+ */
+export class ApiClient {
+    baseUrl;
+    token;
+    fetcher;
+    constructor(baseUrl, token, fetcher = fetch) {
+        this.baseUrl = baseUrl;
+        this.token = token;
+        this.fetcher = fetcher;
+        if (!isSecureServerUrl(baseUrl)) {
+            throw new ValidationError('SOJA servers must use HTTPS (HTTP is allowed only on localhost for development).');
+        }
+    }
+    get(path) {
+        return this.request('GET', path);
+    }
+    post(path, body) {
+        return this.request('POST', path, body ?? {});
+    }
+    patch(path, body) {
+        return this.request('PATCH', path, body);
+    }
+    delete(path) {
+        return this.request('DELETE', path);
+    }
+    /** Like `post`, but also returns the HTTP status (for the login poll's 202). */
+    async postWithStatus(path, body) {
+        const response = await this.send('POST', path, body);
+        return { status: response.status, body: await this.parse(response) };
+    }
+    async request(method, path, body) {
+        return this.parse(await this.send(method, path, body));
+    }
+    async send(method, path, body) {
+        try {
+            return await this.fetcher(`${this.baseUrl}${path}`, {
+                method,
+                headers: {
+                    Accept: 'application/json',
+                    ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+                    ...(this.token ? { Authorization: `Bearer ${this.token}` } : {}),
+                },
+                ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+                signal: AbortSignal.timeout(20_000),
+            });
+        }
+        catch (error) {
+            throw new OfflineError(`Could not reach the SOJA server at ${this.baseUrl}.`, {
+                hint: 'Check your connection. Remote mode needs the server (offline work arrives in v0.4); `soja mode local` works offline.',
+                cause: error,
+            });
+        }
+    }
+    async parse(response) {
+        const text = await response.text();
+        const data = text ? JSON.parse(text, reviveDates) : null;
+        if (response.ok)
+            return data;
+        const error = data?.error;
+        const message = error?.message ?? `The SOJA server answered ${response.status}.`;
+        const options = { ...(error?.hint ? { hint: error.hint } : {}) };
+        if (response.status === 401) {
+            throw new SessionExpiredError(message, { hint: error?.hint ?? 'Run `soja login`.' });
+        }
+        if (response.status === 400)
+            throw new ValidationError(message, options);
+        if (response.status === 404)
+            throw new NotFoundError(message, options);
+        if (response.status === 409)
+            throw new ConflictError(message, options);
+        throw new SojaError(message, options);
+    }
+}

package/dist/data/remote/live.js

@@ -0,0 +1,93 @@
+import { parseServerJson } from './api-client.js';
+const MAX_BACKOFF_MS = 30_000;
+/** Closes that mean retrying cannot help (bad token or no access). */
+const FATAL_CLOSE = new Set([4401, 4403]);
+/**
+ * The real-time channel to the SOJA server (`/v1/live`). It only notifies:
+ * messages still travel as sync operations, so nothing is lost while it is
+ * down. Reconnects with exponential backoff (1 s → 30 s).
+ */
+export class LiveConnection {
+    options;
+    socket = null;
+    timer = null;
+    attempts = 0;
+    stopped = false;
+    ready = false;
+    constructor(options) {
+        this.options = options;
+    }
+    get connected() {
+        return this.ready;
+    }
+    start() {
+        this.stopped = false;
+        this.connect();
+    }
+    stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        this.ready = false;
+        this.socket?.close(1000);
+        this.socket = null;
+    }
+    connect() {
+        if (this.stopped)
+            return;
+        const url = new URL('/v1/live', this.options.apiUrl);
+        url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+        const Socket = this.options.WebSocket ?? globalThis.WebSocket;
+        let socket;
+        try {
+            socket = new Socket(url);
+        }
+        catch {
+            this.retry();
+            return;
+        }
+        this.socket = socket;
+        socket.addEventListener('open', () => {
+            // The token goes in the first message, never in the URL (URLs end up in logs).
+            socket.send(JSON.stringify({ type: 'auth', token: this.options.token, workspaceId: this.options.workspaceId }));
+        });
+        socket.addEventListener('message', (message) => {
+            let event;
+            try {
+                event = parseServerJson(String(message.data));
+            }
+            catch {
+                return;
+            }
+            if (event.type === 'ready') {
+                this.ready = true;
+                this.attempts = 0;
+                this.options.onReady();
+            }
+            else if (this.ready && typeof event.type === 'string') {
+                this.options.onEvent(event);
+            }
+        });
+        socket.addEventListener('close', (event) => {
+            this.ready = false;
+            if (this.socket === socket)
+                this.socket = null;
+            if (!FATAL_CLOSE.has(event.code))
+                this.retry();
+        });
+        // An 'error' is always followed by 'close', which schedules the retry.
+        socket.addEventListener('error', () => undefined);
+    }
+    retry() {
+        if (this.stopped || this.timer)
+            return;
+        const delay = Math.min(MAX_BACKOFF_MS, 1000 * 2 ** this.attempts);
+        this.attempts += 1;
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            this.connect();
+        }, delay);
+        this.timer.unref();
+    }
+}

package/dist/data/repositories.js

@@ -0,0 +1 @@
+export {};

package/dist/data/sync/chat.js

@@ -0,0 +1,242 @@
+import { randomUUID } from 'node:crypto';
+import { CHANNEL_NAME, MAX_MESSAGE_LENGTH, mentions, normalizeChannelName, taskRefsIn } from '../../domain/chat.js';
+import { NotFoundError, SojaError, ValidationError } from '../../domain/errors.js';
+import { formatTaskRef } from '../../domain/task.js';
+import { terminalSafe } from '../../utils/text.js';
+import { OfflineError } from '../remote/api-client.js';
+const TITLE_MAX = 120;
+/**
+ * Chat in remote mode: messages live in the replica, so the chat opens and
+ * reads offline; sends, edits, deletes and read marks are queued operations
+ * the next sync delivers (right away when online).
+ */
+export class ReplicaChatService {
+    context;
+    tasks;
+    constructor(context, tasks) {
+        this.context = context;
+        this.tasks = tasks;
+    }
+    async channels(session) {
+        const [channels, reads] = await Promise.all([this.context.store.channels(session.workspace.id), this.context.store.reads()]);
+        const summaries = await Promise.all(channels.map((channel) => this.summarize(session, channel, reads.get(channel.id) ?? 0)));
+        // #general first, archived last, the rest by name.
+        return summaries.sort((a, b) => Number(a.archivedAt !== null) - Number(b.archivedAt !== null) ||
+            Number(b.name === 'general') - Number(a.name === 'general') ||
+            a.name.localeCompare(b.name));
+    }
+    async totals(session) {
+        const channels = await this.channels(session);
+        return channels.reduce((sum, channel) => ({ unread: sum.unread + channel.unread, mentions: sum.mentions + channel.mentions }), { unread: 0, mentions: 0 });
+    }
+    async channel(session, target) {
+        const name = normalizeChannelName(target);
+        const channel = (await this.channels(session)).find((candidate) => candidate.id === target || candidate.name === name);
+        if (!channel) {
+            throw new NotFoundError(`There is no #${name} channel.`, { hint: 'List them with `soja chat channels`; a sync may bring new ones.' });
+        }
+        return channel;
+    }
+    async messages(session, channelId, limit = 200) {
+        const rows = ordered(await this.context.store.messagesIn(channelId));
+        return this.views(session, rows.slice(-limit), rows);
+    }
+    async send(session, channel, body, options = {}) {
+        const target = await this.channel(session, channel);
+        if (target.archivedAt)
+            throw new ValidationError(`#${target.name} is archived.`, { hint: 'Write in another channel.' });
+        const text = cleanBody(body);
+        const replyToId = options.replyToId ?? null;
+        if (replyToId) {
+            const original = await this.context.store.findMessage(replyToId);
+            if (!original || original.channelId !== target.id)
+                throw new ValidationError('You can only reply to a message in the same channel.');
+        }
+        const message = {
+            id: randomUUID(),
+            seq: null,
+            workspaceId: session.workspace.id,
+            channelId: target.id,
+            authorId: session.user.id,
+            body: text,
+            replyToId,
+            createdAt: new Date(),
+            editedAt: null,
+            deletedAt: null,
+        };
+        await this.context.store.upsertMessage(message);
+        await this.enqueue(session, 'message.send', { messageId: message.id, channelId: target.id, body: text, ...(replyToId ? { replyToId } : {}) });
+        const [view] = await this.views(session, [message], [message]);
+        if (!view)
+            throw new SojaError('The message could not be prepared.');
+        return view;
+    }
+    async edit(session, messageId, body) {
+        const message = await this.own(session, messageId, 'edit');
+        const text = cleanBody(body);
+        if (text === message.body)
+            return;
+        await this.context.store.patchMessage(messageId, { body: text, editedAt: new Date() });
+        await this.enqueue(session, 'message.edit', { messageId, body: text });
+    }
+    async remove(session, messageId) {
+        await this.own(session, messageId, 'delete');
+        await this.context.store.patchMessage(messageId, { body: '', deletedAt: new Date() });
+        await this.enqueue(session, 'message.delete', { messageId });
+    }
+    async markRead(session, channelId) {
+        const seqs = (await this.context.store.messagesIn(channelId)).map((message) => message.seq ?? 0);
+        const latest = Math.max(0, ...seqs);
+        const current = (await this.context.store.reads()).get(channelId) ?? 0;
+        if (latest <= current)
+            return;
+        await this.context.store.markRead(channelId, latest);
+        // Only the newest mark matters: replace one still waiting in the queue.
+        for (const op of await this.context.store.pending(session.workspace.id)) {
+            if (op.type === 'channel.read' && op.payload['channelId'] === channelId && op.attempts === 0)
+                await this.context.store.dropQueued(op.opId);
+        }
+        await this.enqueue(session, 'channel.read', { channelId, lastReadSeq: latest });
+    }
+    async createChannel(session, name, topic = null) {
+        const clean = normalizeChannelName(name);
+        if (!CHANNEL_NAME.test(clean))
+            throw new ValidationError('Channel names use lowercase letters, numbers and dashes (max 40).');
+        const channel = await this.online('Creating a channel', () => this.context.api.post(`/v1/workspaces/${session.workspace.id}/channels`, { name: clean, ...(topic ? { topic: terminalSafe(topic) } : {}) }));
+        await this.context.store.upsertChannel(channel);
+        return this.summarize(session, channel, 0);
+    }
+    async updateChannel(session, channelId, changes) {
+        const payload = {
+            ...(changes.topic !== undefined ? { topic: changes.topic === null ? null : terminalSafe(changes.topic).trim() || null } : {}),
+            ...(changes.archived !== undefined ? { archived: changes.archived } : {}),
+        };
+        const channel = await this.online('Changing a channel', () => this.context.api.patch(`/v1/workspaces/${session.workspace.id}/channels/${channelId}`, payload));
+        await this.context.store.upsertChannel(channel);
+        return this.channel(session, channel.id);
+    }
+    async loadOlder(session, channelId) {
+        const known = (await this.context.store.messagesIn(channelId)).flatMap((message) => (message.seq === null ? [] : [message.seq]));
+        const before = known.length ? Math.min(...known) : null;
+        const older = await this.online('Loading older messages', () => this.context.api.get(`/v1/workspaces/${session.workspace.id}/channels/${channelId}/messages?limit=100${before === null ? '' : `&before=${before}`}`));
+        for (const message of older)
+            await this.context.store.upsertMessage(message);
+        return older.length;
+    }
+    async mentionsOfTask(session, taskNumber, limit = 5) {
+        const ref = formatTaskRef(taskNumber);
+        const rows = (await this.context.store.messagesContaining(session.workspace.id, ref)).filter((message) => message.deletedAt === null && taskRefsIn(message.body).includes(taskNumber));
+        return this.views(session, ordered(rows).reverse().slice(0, limit), rows);
+    }
+    async taskFromMessage(session, messageId) {
+        const message = await this.context.store.findMessage(messageId);
+        if (!message || message.deletedAt)
+            throw new NotFoundError('That message no longer exists.');
+        const channel = await this.context.store.findChannel(message.channelId);
+        const [author] = message.authorId ? await this.context.repos.users.findByIds([message.authorId]) : [];
+        const firstLine = message.body.split('\n').find((line) => line.trim()) ?? message.body;
+        const title = firstLine.trim().length > TITLE_MAX ? `${firstLine.trim().slice(0, TITLE_MAX - 1)}…` : firstLine.trim();
+        const quote = message.body
+            .split('\n')
+            .map((line) => `> ${line}`)
+            .join('\n');
+        const task = await this.tasks.create(session, {
+            title,
+            description: `${author ? `@${author.username}` : 'Someone'} in #${channel?.name ?? 'chat'}:\n${quote}`,
+            ...(author ? { requester: `@${author.username}` } : {}),
+        });
+        // Queued after the task, so the reply reaches the server with its real number.
+        if (channel && !channel.archivedAt)
+            await this.send(session, channel.id, `${symbolArrow} ${task.ref} ${task.title}`, { replyToId: message.id });
+        return task;
+    }
+    // ── Helpers ──────────────────────────────────────────────────────────────
+    async summarize(session, channel, lastReadSeq) {
+        const unread = (await this.context.store.messagesIn(channel.id)).filter((message) => message.seq !== null && message.seq > lastReadSeq && message.authorId !== session.user.id && message.deletedAt === null);
+        return {
+            ...channel,
+            lastReadSeq,
+            unread: unread.length,
+            mentions: unread.filter((message) => mentions(message.body, session.user.username)).length,
+        };
+    }
+    /** Adds authors, the quoted message, and flags. `pool` holds messages a reply may quote. */
+    async views(session, rows, pool) {
+        const pending = new Set();
+        for (const op of await this.context.store.pending(session.workspace.id)) {
+            if (op.type === 'message.send' || op.type === 'message.edit' || op.type === 'message.delete')
+                pending.add(String(op.payload['messageId']));
+        }
+        const byId = new Map(pool.map((message) => [message.id, message]));
+        for (const row of rows) {
+            if (row.replyToId && !byId.has(row.replyToId)) {
+                const quoted = await this.context.store.findMessage(row.replyToId);
+                if (quoted)
+                    byId.set(quoted.id, quoted);
+            }
+        }
+        const authorIds = new Set();
+        for (const message of [...rows, ...byId.values()])
+            if (message.authorId)
+                authorIds.add(message.authorId);
+        const users = new Map((await this.context.repos.users.findByIds([...authorIds])).map((user) => [user.id, { id: user.id, username: user.username, displayName: user.displayName }]));
+        return rows.map((message) => {
+            const quoted = message.replyToId ? byId.get(message.replyToId) : undefined;
+            return {
+                ...message,
+                author: message.authorId ? (users.get(message.authorId) ?? null) : null,
+                pending: pending.has(message.id),
+                mine: message.authorId === session.user.id,
+                mentionsMe: message.authorId !== session.user.id && mentions(message.body, session.user.username),
+                replyTo: quoted
+                    ? { id: quoted.id, author: quoted.authorId ? (users.get(quoted.authorId) ?? null) : null, body: quoted.body, deleted: quoted.deletedAt !== null }
+                    : null,
+            };
+        });
+    }
+    async own(session, messageId, action) {
+        const message = await this.context.store.findMessage(messageId);
+        if (!message || message.deletedAt)
+            throw new NotFoundError('That message no longer exists.');
+        if (message.authorId !== session.user.id)
+            throw new ValidationError(`You can only ${action} your own messages.`);
+        return message;
+    }
+    async enqueue(session, type, payload) {
+        await this.context.store.enqueue({ opId: randomUUID(), workspaceId: session.workspace.id, type, taskId: null, payload, base: null, occurredAt: new Date() }, []);
+        this.context.onWrite();
+    }
+    async online(what, work) {
+        try {
+            return await work();
+        }
+        catch (error) {
+            if (error instanceof OfflineError) {
+                throw new SojaError(`${what} needs a connection to the SOJA server.`, { hint: 'Reading and sending messages work offline.', cause: error });
+            }
+            throw error;
+        }
+    }
+}
+const symbolArrow = '→';
+/** Server order, with messages still waiting to be sent at the end in the order they were written. */
+function ordered(rows) {
+    return [...rows].sort((a, b) => {
+        if (a.seq !== null && b.seq !== null)
+            return a.seq - b.seq;
+        if (a.seq !== null)
+            return -1;
+        if (b.seq !== null)
+            return 1;
+        return a.createdAt.getTime() - b.createdAt.getTime();
+    });
+}
+/** Terminal-safe, trimmed, and within the server's limit. */
+function cleanBody(body) {
+    const text = terminalSafe(body).trim();
+    if (!text)
+        throw new ValidationError('The message is empty.');
+    if (text.length > MAX_MESSAGE_LENGTH)
+        throw new ValidationError(`Keep messages under ${MAX_MESSAGE_LENGTH} characters.`);
+    return text;
+}