@coffer-org/server 1.7.1 → 1.8.0

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/plugin-hooks.d.ts

@@ -2,6 +2,7 @@ import type { EntityManager } from '@mikro-orm/core';
 import type { z } from 'zod';
 import type { ColumnType } from '@coffer-org/sdk/fields';
 import { type Logger } from '@coffer-org/sdk/logger';
+export type { BackgroundTask } from './background-scheduler.ts';
 export interface TableOps {
     renameColumn(from: string, to: string): Promise<void>;
     fill(column: string, value: string | number | boolean | null, opts?: {
@@ -28,21 +29,30 @@ export interface Seed {
     name: string;
     run(ctx: PluginCtx): Promise<void> | void;
 }
+export type AuthRole = 'admin' | 'member';
 export interface AgentTool {
     name: string;
     description: string;
     inputSchema: z.ZodRawShape;
     handler: (args: Record<string, unknown>, ctx: PluginCtx) => Promise<unknown> | unknown;
+    role?: AuthRole;
 }
 export interface AgentContribution {
     instructions?: string | ((ctx: PluginCtx) => string | Promise<string>);
     tools?: AgentTool[];
 }
+export type PluginAction = (body: Record<string, unknown>) => Promise<unknown>;
+export declare class HttpError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
 export interface PluginHooks {
     migrations?: Migration[];
     seed?: Seed[];
     init?(ctx: PluginCtx): Promise<void> | void;
     teardown?(ctx: PluginCtx): Promise<void> | void;
     agent?: AgentContribution;
+    backgroundTasks?: import('./background-scheduler.ts').BackgroundTask[];
+    actions?: Record<string, PluginAction>;
 }
 export declare const pluginHooks: Record<string, PluginHooks>;

package/dist/plugin-hooks.js

@@ -2,4 +2,12 @@ import { getLogger } from '@coffer-org/sdk/logger';
 export function pluginCtx(id, em) {
     return { em, log: getLogger(id) };
 }
+export class HttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'HttpError';
+    }
+}
 export const pluginHooks = {};

package/dist/plugin-runtime.d.ts

@@ -3,6 +3,7 @@ import type { PluginManifest } from '@coffer-org/sdk/plugin';
 export declare function getPlugins(): Promise<PluginManifest[]>;
 export declare function readDisabled(): Promise<Set<string>>;
 export declare function getPluginSettings(pluginId: string): Promise<Record<string, unknown>>;
+export declare function requireSettings<K extends string>(pluginId: string, keys: readonly K[]): Promise<Record<K, string>>;
 export declare function initStorage(): Promise<Set<string>>;
 export declare function initPlugins(): Promise<Registry>;
 export declare function teardownPlugins(): Promise<void>;

package/dist/plugin-runtime.js

@@ -3,13 +3,14 @@ import { composeRegistry } from '@coffer-org/core/compose';
 import { getLogger } from '@coffer-org/sdk/logger';
 import { initDb, getOrm, getEm } from "./db.js";
 import { syncSchema } from "./schema-sync.js";
-import { systemEntities, buildPluginEntities, moduleTableName } from "./entity-schema.js";
-import { pluginHooks, pluginCtx } from "./plugin-hooks.js";
+import { systemEntities, buildPluginEntities, shelfTableName } from "./entity-schema.js";
+import { pluginHooks, pluginCtx, HttpError } from "./plugin-hooks.js";
 import { discoverPlugins, loadServerHooks } from "./plugin-discovery.js";
 import { runMigrations, assertSafeRequired } from "./migrations.js";
 import { runSeeds } from "./seeds.js";
 import { setActiveRegistry } from "./registry-context.js";
 import { migrateEmbeddingVectorsToBlob } from "./embeddings.js";
+import { startScheduler, stopScheduler } from "./background-scheduler.js";
 const log = getLogger('plugins');
 let _plugins = null;
 export async function getPlugins() {
@@ -36,6 +37,22 @@ export async function getPluginSettings(pluginId) {
         return {};
     }
 }
+export async function requireSettings(pluginId, keys) {
+    const s = await getPluginSettings(pluginId);
+    const out = {};
+    const missing = [];
+    for (const k of keys) {
+        const v = s[k];
+        if (v == null || v === '')
+            missing.push(k);
+        else
+            out[k] = String(v);
+    }
+    if (missing.length) {
+        throw new HttpError(400, `${pluginId} settings not configured: ${missing.join(', ')}. Save them first.`);
+    }
+    return out;
+}
 async function seedPluginRows() {
     const fork = getEm().fork();
     const existing = new Set((await fork.find('_Plugin', {})).map((r) => r.id));
@@ -74,6 +91,7 @@ export async function initPlugins() {
     setActiveRegistry(reg);
     Object.assign(pluginHooks, await loadServerHooks());
     await runSeeds({ em: getEm().fork(), plugins: reg.order, hooks: pluginHooks });
+    const bgTasks = [];
     for (const p of reg.order) {
         const h = pluginHooks[p.id];
         try {
@@ -81,17 +99,23 @@ export async function initPlugins() {
                 await h.init(pluginCtx(p.id, getEm().fork()));
                 log.debug(`${p.id}: init ✓`);
             }
+            for (const task of h?.backgroundTasks ?? [])
+                bgTasks.push(task);
         }
         catch (err) {
             log.error(`${p.id}: initialization failure`, err);
             throw err;
         }
     }
+    startScheduler(bgTasks);
+    if (bgTasks.length)
+        log.debug(`scheduler: ${bgTasks.length} background task(s): ${bgTasks.map((t) => t.name).join(' ')}`);
     log.info(`active: ${reg.order.map((p) => p.id).join(' ')}` +
         (disabled.size ? ` | disabled: ${[...disabled].join(' ')}` : ''));
     return reg;
 }
 export async function teardownPlugins() {
+    stopScheduler();
     Object.assign(pluginHooks, await loadServerHooks());
     const disabled = await readDisabled();
     const reg = composeRegistry(await getPlugins(), { disabled });
@@ -115,15 +139,15 @@ export async function teardownPlugin(id) {
         log.debug(`${id}: teardown ✓`);
     }
 }
-function pluginModules(p) {
+function pluginShelves(p) {
     return [
-        ...(p.vaults ?? []).flatMap((v) => v.modules.map((m) => ({ vault: m.vault, module: m.module }))),
-        ...(p.vaultModules ?? []).map((m) => ({ vault: m.vault, module: m.module })),
+        ...(p.libraries ?? []).flatMap((v) => v.shelves.map((m) => ({ library: m.library, shelf: m.shelf }))),
+        ...(p.libraryShelves ?? []).map((m) => ({ library: m.library, shelf: m.shelf })),
     ];
 }
 function pluginTables(p) {
     return [
-        ...pluginModules(p).map(({ vault, module }) => moduleTableName(vault, module)),
+        ...pluginShelves(p).map(({ library, shelf }) => shelfTableName(library, shelf)),
         ...(p.extends_ ?? []).map((e) => `extend__${e.id}`),
         ...(p.settings && p.settings.fields.length > 0 ? [`_settings__${p.id}`] : []),
     ];

package/dist/plugins-api.d.ts

@@ -8,7 +8,7 @@ export interface PluginListEntry {
     packageName: string | null;
     dependsOn: string[];
     enabled: boolean;
-    vaults: string[];
+    libraries: string[];
     extends: string[];
     hasSettings: boolean;
     schema?: string;