@coffer-org/server 1.7.1 → 1.9.0

package/dist/mcp-http.test-helpers.js

@@ -0,0 +1,117 @@
+import Fastify from 'fastify';
+import { initDb, closeDb } from "./db.js";
+import { systemEntities } from "./entity-schema.js";
+import { registerAuthApi, resolveRequestUser, PUBLIC_API_PATHS } from "./auth-api.js";
+import { registerMcpHttp } from "./mcp-http.js";
+import { createUser, createApiToken } from "./auth-store.js";
+import { pluginHooks } from "./plugin-hooks.js";
+let currentAdminToken;
+let currentMemberToken;
+export async function freshMcpApp(opts = {}) {
+    process.env['DB_PATH'] = ':memory:';
+    const orm = await initDb(systemEntities);
+    await orm.schema.update({ safe: false, dropTables: false });
+    const app = Fastify();
+    app.addHook('onRequest', async (req, reply) => {
+        const gated = req.url.startsWith('/api/') || req.url.startsWith('/uploads/') || req.url === '/mcp' || req.url.startsWith('/mcp?');
+        if (!gated)
+            return;
+        if (PUBLIC_API_PATHS.some((p) => req.url.startsWith(p)))
+            return;
+        const user = await resolveRequestUser(req);
+        if (!user)
+            return reply.code(401).send({ error: 'unauthorized' });
+        req.user = user;
+    });
+    await registerAuthApi(app);
+    await registerMcpHttp(app);
+    const admin = await createUser({ login: 'admin', password: 'hunter2', displayName: 'Admin', role: 'admin' });
+    const member = await createUser({ login: 'member', password: 'hunter2', displayName: 'Member', role: 'member' });
+    currentAdminToken = `admin-raw-token-${Math.random().toString(36).slice(2)}`;
+    currentMemberToken = `member-raw-token-${Math.random().toString(36).slice(2)}`;
+    await createApiToken(admin.id, 'admin-token', currentAdminToken);
+    await createApiToken(member.id, 'member-token', currentMemberToken);
+    if (opts.withAdminTool || opts.withInstructions) {
+        pluginHooks['demo'] = {
+            agent: {
+                ...(opts.withInstructions ? { instructions: 'Demo library — widgets.' } : {}),
+                ...(opts.withAdminTool
+                    ? { tools: [{ name: 'danger', description: 'd', inputSchema: {}, role: 'admin', handler: () => 1 }] }
+                    : {}),
+            },
+        };
+    }
+    const origClose = app.close.bind(app);
+    app.close = ((...args) => {
+        delete pluginHooks['demo'];
+        return origClose(...args);
+    });
+    return app;
+}
+export async function adminToken() {
+    if (!currentAdminToken)
+        throw new Error('adminToken() called before freshMcpApp()');
+    return currentAdminToken;
+}
+export async function memberToken() {
+    if (!currentMemberToken)
+        throw new Error('memberToken() called before freshMcpApp()');
+    return currentMemberToken;
+}
+export function parseRpcResult(res) {
+    const contentType = String(res.headers['content-type'] ?? '');
+    const raw = [];
+    if (contentType.includes('text/event-stream')) {
+        for (const line of res.body.split('\n')) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('data:'))
+                raw.push(trimmed.slice('data:'.length).trim());
+        }
+    }
+    else {
+        raw.push(res.body);
+    }
+    for (const s of raw) {
+        if (!s)
+            continue;
+        try {
+            const parsed = JSON.parse(s);
+            const msg = (Array.isArray(parsed) ? parsed : [parsed]).find((m) => m.result);
+            if (msg?.result)
+                return msg.result;
+        }
+        catch {
+        }
+    }
+    return undefined;
+}
+export function parseToolNames(res) {
+    const contentType = String(res.headers['content-type'] ?? '');
+    const messages = [];
+    if (contentType.includes('text/event-stream')) {
+        for (const line of res.body.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith('data:'))
+                continue;
+            const jsonStr = trimmed.slice('data:'.length).trim();
+            if (!jsonStr)
+                continue;
+            try {
+                messages.push(JSON.parse(jsonStr));
+            }
+            catch {
+            }
+        }
+    }
+    else {
+        try {
+            const parsed = JSON.parse(res.body);
+            messages.push(...(Array.isArray(parsed) ? parsed : [parsed]));
+        }
+        catch {
+        }
+    }
+    const withTools = messages.find((m) => m.result?.tools);
+    return (withTools?.result?.tools ?? []).map((t) => t.name);
+}
+export { closeDb };

package/dist/mcp-local.d.ts

@@ -0,0 +1,10 @@
+import type { CofferClientApi } from '@coffer-org/mcp/client';
+export declare function mapError(e: unknown): never;
+export declare class LocalClient implements CofferClientApi {
+    getSchema(): Promise<unknown>;
+    listRecords(library: string, type: string, query?: Record<string, unknown>): Promise<unknown>;
+    getRecord(library: string, type: string, id: number): Promise<unknown>;
+    createRecord(library: string, type: string, fields: Record<string, unknown>): Promise<unknown>;
+    updateRecord(library: string, type: string, id: number, fields: Record<string, unknown>): Promise<unknown>;
+    deleteRecord(library: string, type: string, id: number): Promise<unknown>;
+}

package/dist/mcp-local.js

@@ -0,0 +1,57 @@
+import { ValidationError, NotFoundError } from '@coffer-org/mcp/client';
+import { recordList, recordGet, recordCreate, recordUpdate, recordDelete, UnknownTypeError, } from "./records-api.js";
+import { ValidationError as ServerValidationError } from "./mutate.js";
+import { buildClientSchema } from "./schema-api.js";
+export function mapError(e) {
+    if (e instanceof ServerValidationError)
+        throw new ValidationError(e.issues ?? []);
+    if (e instanceof UnknownTypeError)
+        throw new NotFoundError('not_found');
+    throw e;
+}
+export class LocalClient {
+    async getSchema() {
+        return buildClientSchema();
+    }
+    async listRecords(library, type, query = {}) {
+        try {
+            return await recordList(library, type, query);
+        }
+        catch (e) {
+            mapError(e);
+        }
+    }
+    async getRecord(library, type, id) {
+        try {
+            return await recordGet(library, type, id);
+        }
+        catch (e) {
+            mapError(e);
+        }
+    }
+    async createRecord(library, type, fields) {
+        try {
+            return await recordCreate(library, type, fields);
+        }
+        catch (e) {
+            mapError(e);
+        }
+    }
+    async updateRecord(library, type, id, fields) {
+        try {
+            return await recordUpdate(library, type, id, fields);
+        }
+        catch (e) {
+            mapError(e);
+        }
+    }
+    async deleteRecord(library, type, id) {
+        try {
+            await recordDelete(library, type, id);
+            return null;
+        }
+        catch (e) {
+            mapError(e);
+        }
+    }
+}

package/dist/mcp-tools.d.ts

@@ -0,0 +1,61 @@
+import type { EntityManager } from '@mikro-orm/core';
+import { z } from 'zod';
+import { type ToolResult } from '@coffer-org/mcp';
+import { type AuthRole, type PluginHooks } from './plugin-hooks.ts';
+import { type Condition } from '@coffer-org/sdk/condition';
+import { type EmbeddingHit } from './embeddings.ts';
+export interface McpToolDef {
+    server: string;
+    bareName: string;
+    httpName: string;
+    description: string;
+    inputSchema: z.ZodRawShape;
+    scope: 'crud' | 'plugin' | 'rag' | 'settings';
+    role: AuthRole;
+    handler: (args: Record<string, unknown>) => Promise<ToolResult>;
+}
+export interface RagDeps {
+    embeddingApiKey: string;
+    topK: number;
+}
+export declare function formatHits(hits: EmbeddingHit[]): string;
+export declare function resolveRagDeps(): Promise<RagDeps | null>;
+export declare function collectMcpTools(opts?: {
+    rag?: RagDeps | null;
+    includeAdmin?: boolean;
+    actor?: string;
+}): Promise<McpToolDef[]>;
+export declare function collectPluginInstructions(hooks?: Record<string, PluginHooks>, emFactory?: () => EntityManager): Promise<{
+    id: string;
+    instructions: string;
+}[]>;
+type LibraryPurpose = {
+    id: string;
+    agent: string;
+    extends: {
+        id: string;
+        shelf: string;
+        claude: string;
+        showWhen?: Condition;
+    }[];
+};
+export declare function collectLibraryPurposes(reg?: {
+    libraries: {
+        meta: {
+            id: string;
+            agent?: string;
+        };
+    }[];
+    extends_: {
+        id: string;
+        claude?: string;
+        showWhen?: Condition;
+        attachTo: {
+            library: string;
+            shelf: string;
+        }[];
+    }[];
+}): LibraryPurpose[];
+export declare function buildDomainSections(): Promise<string[]>;
+export declare function buildMcpInstructions(sections: string[]): string;
+export {};

package/dist/mcp-tools.js

@@ -0,0 +1,225 @@
+import { z } from 'zod';
+import { buildTools } from '@coffer-org/mcp';
+import { SchemaCache } from '@coffer-org/mcp/schema';
+import { LocalClient } from "./mcp-local.js";
+import { pluginHooks, pluginCtx } from "./plugin-hooks.js";
+import { getActiveRegistry } from "./registry-context.js";
+import { describeCondition } from '@coffer-org/sdk/condition';
+import { getEm } from "./db.js";
+import { getPluginSettings } from "./plugin-runtime.js";
+import { searchEmbeddings } from "./embeddings.js";
+import { embedOne } from "./embed-openai.js";
+import { getLogger } from "./log.js";
+import { writePluginSettings, listSettings } from "./settings-write.js";
+import { ValidationError, NotFoundError } from "./mutate.js";
+const log = getLogger('mcp-tools');
+export function formatHits(hits) {
+    if (hits.length === 0)
+        return 'No matching records.';
+    return hits
+        .map((h) => `[${h.type}/${h.recordId}] (dist ${h.distance.toFixed(3)})\n${h.snippet}`)
+        .join('\n\n');
+}
+const ok = (data) => ({
+    content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+});
+const fail = (text) => ({ content: [{ type: 'text', text }], isError: true });
+export async function resolveRagDeps() {
+    const db = (await getPluginSettings('claude-agent'));
+    const enabled = db['rag_enabled'] !== false;
+    const embeddingApiKey = (process.env.OPENAI_API_KEY ?? db['openai_api_key'] ?? '');
+    const topK = Number(process.env.AGENT_RAG_TOP_K ?? db['rag_top_k'] ?? 5) || 5;
+    if (!enabled || !embeddingApiKey)
+        return null;
+    return { embeddingApiKey, topK };
+}
+export async function collectMcpTools(opts = {}) {
+    const out = [];
+    const client = new LocalClient();
+    const cache = new SchemaCache(client);
+    for (const t of buildTools(client, cache)) {
+        out.push({
+            server: 'coffer',
+            bareName: t.name,
+            httpName: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema,
+            scope: 'crud',
+            role: 'member',
+            handler: t.handler,
+        });
+    }
+    for (const [id, h] of Object.entries(pluginHooks)) {
+        for (const t of h.agent?.tools ?? []) {
+            out.push({
+                server: id,
+                bareName: t.name,
+                httpName: `${id}_${t.name}`,
+                description: t.description,
+                inputSchema: t.inputSchema,
+                scope: 'plugin',
+                role: t.role ?? 'member',
+                handler: async (args) => {
+                    try {
+                        const data = await t.handler(args, pluginCtx(id, getEm().fork()));
+                        return ok(data);
+                    }
+                    catch (e) {
+                        return fail(`Error: ${e.message}`);
+                    }
+                },
+            });
+        }
+    }
+    if (opts.rag) {
+        const { embeddingApiKey, topK } = opts.rag;
+        out.push({
+            server: 'rag',
+            bareName: 'search_records',
+            httpName: 'search_records',
+            description: "Semantic search over the user's coffer records. Returns the most relevant records as type/id refs with a text snippet.",
+            inputSchema: { query: z.string(), k: z.number().int().positive().optional() },
+            scope: 'rag',
+            role: 'member',
+            handler: async (args) => {
+                try {
+                    const { vector } = await embedOne(args.query, embeddingApiKey);
+                    const hits = await searchEmbeddings(vector, args.k ?? topK);
+                    return { content: [{ type: 'text', text: formatHits(hits) }] };
+                }
+                catch (e) {
+                    return fail(`Error: ${e.message}`);
+                }
+            },
+        });
+    }
+    if (opts.includeAdmin) {
+        const actor = opts.actor ?? 'mcp';
+        out.push({
+            server: 'coffer',
+            bareName: 'list_settings',
+            httpName: 'list_settings',
+            description: 'List every plugin and system settings group (including "core"): each field\'s key/kind/required and the current values (secrets masked). Call before update_settings.',
+            inputSchema: {},
+            scope: 'settings',
+            role: 'admin',
+            handler: async () => {
+                try {
+                    return ok(await listSettings());
+                }
+                catch (e) {
+                    return fail(`Error: ${e.message}`);
+                }
+            },
+        });
+        out.push({
+            server: 'coffer',
+            bareName: 'update_settings',
+            httpName: 'update_settings',
+            description: 'Update a plugin or system settings group. plugin — the plugin id (e.g. "claude-agent", "core"); fields — only the settings to change (see list_settings). Send real secret values; the masked placeholder (********) is treated as unchanged.',
+            inputSchema: { plugin: z.string(), fields: z.record(z.string(), z.unknown()) },
+            scope: 'settings',
+            role: 'admin',
+            handler: async (args) => {
+                try {
+                    const row = await writePluginSettings(getEm().fork(), args.plugin, args.fields, actor);
+                    return ok(row);
+                }
+                catch (e) {
+                    if (e instanceof ValidationError) {
+                        const lines = e.issues.map((i) => {
+                            const o = i;
+                            return `- ${o.field ?? '?'}: ${o.code ?? 'invalid'}`;
+                        });
+                        return fail(`Validation error:\n${lines.join('\n')}`);
+                    }
+                    if (e instanceof NotFoundError)
+                        return fail(`Plugin '${String(args.plugin)}' has no settings.`);
+                    return fail(`Error: ${e.message}`);
+                }
+            },
+        });
+    }
+    return out;
+}
+export async function collectPluginInstructions(hooks = pluginHooks, emFactory = () => getEm().fork()) {
+    const out = [];
+    for (const [id, h] of Object.entries(hooks)) {
+        const a = h.agent;
+        if (a?.instructions == null)
+            continue;
+        try {
+            const instructions = typeof a.instructions === 'function' ? await a.instructions(pluginCtx(id, emFactory())) : a.instructions;
+            if (instructions)
+                out.push({ id, instructions });
+        }
+        catch (e) {
+            log.warn(`plugin ${id}: instructions skipped — ${e.message}`);
+        }
+    }
+    return out;
+}
+export function collectLibraryPurposes(reg) {
+    let registry = reg;
+    if (!registry) {
+        try {
+            registry = getActiveRegistry();
+        }
+        catch {
+            return [];
+        }
+    }
+    if (!registry)
+        return [];
+    return registry.libraries
+        .filter((v) => v.meta.agent)
+        .map((v) => ({
+        id: v.meta.id,
+        agent: v.meta.agent,
+        extends: registry.extends_.flatMap((e) => e.claude
+            ? e.attachTo
+                .filter((a) => a.library === v.meta.id)
+                .map((a) => ({ id: e.id, shelf: a.shelf, claude: e.claude, showWhen: e.showWhen }))
+            : []),
+    }));
+}
+export async function buildDomainSections() {
+    const libraries = collectLibraryPurposes();
+    let overview = null;
+    if (libraries.length) {
+        const blocks = libraries.map((v) => {
+            let s = `### ${v.id} — ${v.agent}`;
+            if (v.extends.length) {
+                s +=
+                    '\nExtra field-sets some records carry (which one depends on the record):\n' +
+                        v.extends
+                            .map((e) => {
+                            const when = describeCondition(e.showWhen, (f) => f).join(' and ');
+                            return `- ${e.id} (on ${e.shelf}${when ? `, when ${when}` : ''}): ${e.claude.replace(/\s*\n\s*/g, ' ')}`;
+                        })
+                            .join('\n');
+            }
+            return s;
+        });
+        overview =
+            '## Libraries (what each holds / when to use it — pick the right one before searching)\n\n' + blocks.join('\n\n');
+    }
+    const dataModel = '## Data model\n' +
+        'Library (top-level area) → type/shelf (a kind of record, e.g. things/item) → record (addressed library/type/id) → fields. ' +
+        'Some field values are JSON (e.g. quantity {"value":2000,"unit":"ml"}); some are relations (hold another record\'s id); ' +
+        'some are collections (nested rows — an array). Extends add extra field-sets to a type\'s records, shown only when a ' +
+        'condition holds (the "when …" notes below); in a fetched record they sit under `_extends`. ' +
+        'Read: list_libraries → describe_type → list_records/get_record. Write: create_record/update_record (call describe_type first); ' +
+        'to remove a record use delete_record — do not blank its fields.';
+    const rules = (await collectPluginInstructions()).map(({ id, instructions }) => `## ${id}\n${instructions}`);
+    return overview ? [dataModel, overview, ...rules] : [dataModel, ...rules];
+}
+export function buildMcpInstructions(sections) {
+    const base = [
+        "Coffer is the user's personal database, organized into libraries (kitchen, people, finance, health, devices, home, garden, documents, travel, and more), each holding typed records.",
+        'Use the tools to read and write this data: call list_libraries to see what exists, describe_type before create_record/update_record, then list_records / get_record to read. When a search_records tool is available, use it for semantic lookup.',
+        'The per-library notes below name the shelves and the rules — not every field. For exact field names, types, and which are required, call describe_type(library, type) rather than guessing from the notes.',
+        'Record field values may be JSON-encoded (e.g. quantity {"value":2000,"unit":"ml"}) — parse them.',
+    ].join('\n');
+    return sections.length ? `${base}\n\n${sections.join('\n\n')}` : base;
+}

package/dist/msg-log.d.ts

@@ -4,7 +4,6 @@ export interface MsgLogRow {
     userId: string;
     role: 'user' | 'assistant';
     text: string;
-    sessionId: string | null;
     tokensIn: number | null;
     tokensOut: number | null;
     ms: number | null;

package/dist/msg-log.js

@@ -1,5 +1,5 @@
 import { getEm } from "./db.js";
 export async function logMessage(row) {
-    await getEm().fork().getConnection().execute(`INSERT INTO _orch_msg_log (ts, connector, chat_id, user_id, role, text, session_id, tokens_in, tokens_out, ms)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [new Date().toISOString(), row.connector, row.chatId, row.userId, row.role, row.text, row.sessionId, row.tokensIn, row.tokensOut, row.ms]);
+    await getEm().fork().getConnection().execute(`INSERT INTO _orch_msg_log (ts, connector, chat_id, user_id, role, text, tokens_in, tokens_out, ms)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [new Date().toISOString(), row.connector, row.chatId, row.userId, row.role, row.text, row.tokensIn, row.tokensOut, row.ms]);
 }

package/dist/mutate.d.ts

@@ -1,8 +1,10 @@
-import type { ModuleDef } from '@coffer-org/sdk/module';
+import type { EntityManager } from '@mikro-orm/core';
+import type { ShelfDef } from '@coffer-org/sdk/shelf';
 import { z } from 'zod';
 export interface MutateCtx {
     actor: string;
 }
+export type AfterBaseHook = (tx: EntityManager, id: number) => Promise<Record<string, unknown> | void>;
 export interface ValidationIssue {
     field: string;
     code: string;
@@ -18,7 +20,7 @@ export declare class NotFoundError extends Error {
 }
 export declare function toIssue(i: z.ZodIssue): ValidationIssue;
 export declare function listRecords(entityName: string): Promise<Record<string, unknown>[]>;
-export declare function getRecord(m: ModuleDef, entityName: string, id: number): Promise<Record<string, unknown> | undefined>;
-export declare function createRecord(m: ModuleDef, entityName: string, input: unknown, ctx: MutateCtx): Promise<Record<string, unknown>>;
-export declare function updateRecord(m: ModuleDef, entityName: string, id: number, input: unknown, ctx: MutateCtx): Promise<Record<string, unknown>>;
-export declare function deleteRecord(m: ModuleDef, entityName: string, id: number, ctx: MutateCtx): Promise<void>;
+export declare function getRecord(m: ShelfDef, entityName: string, id: number): Promise<Record<string, unknown> | undefined>;
+export declare function createRecord(m: ShelfDef, entityName: string, input: unknown, ctx: MutateCtx, afterBase?: AfterBaseHook): Promise<Record<string, unknown>>;
+export declare function updateRecord(m: ShelfDef, entityName: string, id: number, input: unknown, ctx: MutateCtx, afterBase?: AfterBaseHook): Promise<Record<string, unknown>>;
+export declare function deleteRecord(m: ShelfDef, entityName: string, id: number, ctx: MutateCtx, afterBase?: AfterBaseHook): Promise<void>;

package/dist/mutate.js

@@ -1,8 +1,9 @@
 import { serialize } from '@mikro-orm/core';
-import { buildZodObject, buildZodObjectPartial, fieldEntries } from '@coffer-org/sdk/module';
+import { buildZodObject, buildZodObjectPartial, fieldEntries } from '@coffer-org/sdk/shelf';
 import { isJsonStored, decodeVmsg } from '@coffer-org/sdk/fields';
 import { resolveFlag } from '@coffer-org/sdk/condition';
 import { getEm } from "./db.js";
+import { notifyRecordsChanged } from "./index-signal.js";
 import { encodeTemporal, decodeTemporal } from "./temporal.js";
 import { splitCollections, writeCollections, deleteCollections, flattenEmbedded, nestEmbedded, readCollections, } from "./collection-io.js";
 function nowIso() {
@@ -63,7 +64,7 @@ export async function getRecord(m, entityName, id) {
     const collections = await readCollections(fork, m, id);
     return { ...nested, ...collections };
 }
-export async function createRecord(m, entityName, input, ctx) {
+export async function createRecord(m, entityName, input, ctx, afterBase) {
     const parsed = buildZodObject(m).safeParse(input);
     if (!parsed.success)
         throw new ValidationError(parsed.error.issues.map(toIssue));
@@ -79,11 +80,17 @@ export async function createRecord(m, entityName, input, ctx) {
         await tx.flush();
         id = entity.id;
         await writeCollections(tx, m, id, collections);
-        writeEvent(tx, ctx.actor, 'create', `${m.vault}/${m.module}`, id, null, { ...parsedData, id });
+        const _extends = afterBase ? await afterBase(tx, id) : undefined;
+        writeEvent(tx, ctx.actor, 'create', `${m.library}/${m.shelf}`, id, null, {
+            ...parsedData,
+            id,
+            ...(_extends ? { _extends } : {}),
+        });
     });
+    notifyRecordsChanged();
     return { ...parsedData, id, created_at: ts, updated_at: ts };
 }
-export async function updateRecord(m, entityName, id, input, ctx) {
+export async function updateRecord(m, entityName, id, input, ctx, afterBase) {
     const parsed = buildZodObjectPartial(m).safeParse(input);
     if (!parsed.success)
         throw new ValidationError(parsed.error.issues.map(toIssue));
@@ -117,13 +124,15 @@ export async function updateRecord(m, entityName, id, input, ctx) {
         await tx.upsert(entityName, dbRow);
         await writeCollections(tx, m, id, collections);
         const allCollections = await readCollections(tx, m, id);
-        const after = { ...merged, ...allCollections, updated_at: ts };
-        writeEvent(tx, ctx.actor, 'update', `${m.vault}/${m.module}`, id, existing, after);
+        const _extends = afterBase ? await afterBase(tx, id) : undefined;
+        const after = { ...merged, ...allCollections, updated_at: ts, ...(_extends ? { _extends } : {}) };
+        writeEvent(tx, ctx.actor, 'update', `${m.library}/${m.shelf}`, id, existing, after);
         result = after;
     });
+    notifyRecordsChanged();
     return result;
 }
-export async function deleteRecord(m, entityName, id, ctx) {
+export async function deleteRecord(m, entityName, id, ctx, afterBase) {
     await getEm()
         .fork()
         .transactional(async (tx) => {
@@ -132,7 +141,10 @@ export async function deleteRecord(m, entityName, id, ctx) {
             throw new NotFoundError();
         const existing = serialize(found);
         await deleteCollections(tx, m, id);
+        if (afterBase)
+            await afterBase(tx, id);
         tx.remove(found);
-        writeEvent(tx, ctx.actor, 'delete', `${m.vault}/${m.module}`, id, existing, null);
+        writeEvent(tx, ctx.actor, 'delete', `${m.library}/${m.shelf}`, id, existing, null);
     });
+    notifyRecordsChanged();
 }

package/dist/oauth-api.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from 'fastify';
+export declare function registerOAuthApi(app: FastifyInstance): void;