@coffer-org/server 7.2.0 → 7.4.0

package/dist/orchestrator/turn-context.js

@@ -0,0 +1,39 @@
+import { currentMoment } from "./environment.js";
+export const PAUSE_THRESHOLD_MS = 10 * 60_000;
+export const MAX_SPEAKER_NAME = 80;
+const FORGERY_CHARS = /[\p{Cc}\p{Zl}\p{Zp}\p{Bidi_Control}]+/gu;
+export function oneLine(value, maxLen) {
+    const flat = value.replace(FORGERY_CHARS, ' ').replace(/\s+/g, ' ').trim();
+    return maxLen !== undefined && flat.length > maxLen ? `${flat.slice(0, maxLen - 1).trimEnd()}…` : flat;
+}
+export function humanizePause(ms) {
+    const minutes = Math.round(ms / 60_000);
+    if (minutes < 90)
+        return `about ${minutes} minutes`;
+    const hours = Math.round(ms / 3_600_000);
+    if (hours < 48)
+        return `about ${hours} hours`;
+    return `about ${Math.round(ms / 86_400_000)} days`;
+}
+export function buildTurnContext(input) {
+    const name = oneLine(input.speaker.name, MAX_SPEAKER_NAME) || 'unknown';
+    const previousName = input.previousSpeakerName
+        ? oneLine(input.previousSpeakerName, MAX_SPEAKER_NAME) || 'unknown'
+        : null;
+    const who = `${name} (${input.speaker.role})`;
+    const lines = [
+        previousName ? `Speaking now: ${who} — the previous message was from ${previousName}.` : `Speaking now: ${who}.`,
+        `Current time: ${currentMoment(input.now, input.timeZone)} (${input.timeZone}).`,
+    ];
+    if (input.previousMessageTs !== null) {
+        const gap = input.now.getTime() - input.previousMessageTs * 1000;
+        if (gap >= PAUSE_THRESHOLD_MS)
+            lines.push(`Time since the previous message: ${humanizePause(gap)}.`);
+    }
+    for (const raw of input.connectorLines) {
+        const line = oneLine(raw);
+        if (line)
+            lines.push(line);
+    }
+    return lines.join('\n');
+}

package/dist/orchestrator/types.d.ts

@@ -1,3 +1,12 @@
+import type { ImageTarget } from '../media/index.ts';
+import type { AuthRole } from '../plugin-hooks.ts';
+import type { ContextFact } from './context-facts.ts';
+import type { SystemAreas } from './system-areas.ts';
+import type { StoredAttachment } from '../conversation-store.ts';
+export type { ImageTarget };
+export type { ContextFact };
+export type { SystemAreas };
+export type { StoredAttachment };
 export interface AttachmentRef {
     name: string;
     mime?: string;
@@ -9,7 +18,6 @@ export interface AgentToolDefinition {
     description: string;
     inputSchema: Record<string, unknown>;
     handler: (args: Record<string, unknown>, signal?: AbortSignal) => Promise<unknown>;
-    forcedAfterAnswer?: boolean;
 }
 export interface AgentToolProvider {
     tools: AgentToolDefinition[];
@@ -34,18 +42,25 @@ export interface AgentToolContentResult {
 export interface ConvMessage {
     role: 'user' | 'assistant';
     content: string;
-    context?: string;
+    context?: ContextFact[];
     attachments?: AttachmentRef[];
     sender?: string | null;
     msgId: string;
     ts: number;
 }
 export interface AgentCapabilities {
-    vision?: boolean;
-    documents?: boolean;
     tools?: boolean;
     reasoning?: boolean;
 }
+export interface AgentMediaKind {
+    maxBytes: number;
+    accepts: readonly string[];
+}
+export interface AgentMediaLimits {
+    image: AgentMediaKind & ImageTarget;
+    document: AgentMediaKind;
+    text: AgentMediaKind;
+}
 export interface AgentPreset {
     id: string;
     title: string;
@@ -60,35 +75,42 @@ export interface AgentDescriptor {
     title: string;
     presets: AgentPreset[];
 }
+export interface AgentCatalogEntry extends AgentDescriptor {
+    media: AgentMediaLimits;
+}
 export interface AgentBudget {
     responseTimeout?: number;
     toolRounds?: number;
 }
-export interface AgentRequest {
-    system: string;
-    messages: ConvMessage[];
+export interface AgentTurn {
+    envelope: TurnEnvelope;
+    body: {
+        system: string[];
+        messages: ConvMessage[];
+        userMessageCount: number;
+    };
     toolProvider?: AgentToolProvider;
     presetId?: string;
     budget?: AgentBudget;
-    onDelta?: (accumulated: string) => void;
-    onReasoning?: (accumulated: string) => void;
-    onSegment?: () => void;
-}
-export interface AgentResult {
-    text: string | null;
-    reasoning: string | null;
-    tokensIn: number | null;
-    tokensOut: number | null;
-    stopReason: string | null;
-    presetId: string | null;
-    suggestions?: string[] | null;
+    senderRole?: AuthRole;
+    signal?: AbortSignal;
 }
 export interface AgentRuntime {
     id: string;
-    run(request: AgentRequest): Promise<AgentResult>;
+    media: AgentMediaLimits;
+    run(turn: AgentTurn, emit: (e: TurnEvent) => void): Promise<void>;
     systemBase(): Promise<string>;
     describe(): Promise<AgentDescriptor>;
     starters?(hint: string): Promise<string[]>;
+    afterword?(turn: AgentTurn, answer: string, want: {
+        suggestions: boolean;
+        title: boolean;
+    }): Promise<{
+        suggestions?: string[];
+        title?: string;
+        tokensIn?: number;
+        tokensOut?: number;
+    }>;
 }
 export interface ConnectorRegistration {
     id: string;
@@ -99,48 +121,77 @@ export interface AttachmentMaterializer {
         mime?: string;
     }): Promise<AttachmentRef>;
 }
-export interface IncomingConversation {
+export interface TurnEnvelope {
     connectorId: string;
-    agentId?: string;
-    presetId?: string;
-    chatId: string;
-    channelSystem?: string;
-    turnContext?: string;
+    conversationId: string;
+    turnId: string;
+}
+export interface ConnectorCapabilities {
+    events: readonly ('delta' | 'reasoning' | 'segment' | 'suggestions' | 'title')[];
+    privateChats: boolean;
+}
+export interface TurnBody {
+    systemPrompt: SystemAreas;
+    capabilities: ConnectorCapabilities;
+}
+export interface TurnRequest {
+    envelope: TurnEnvelope;
     sender: {
-        id: string;
+        userId: number;
         displayName?: string;
     };
-    messages: ConvMessage[];
-    prepareAttachments?: (materializer: AttachmentMaterializer) => Promise<ConvMessage[]>;
-    supportsSuggestions?: boolean;
-}
-export interface ReplyContext {
-    parentMsgId: string | null;
+    message?: {
+        text: string;
+        attachments?: StoredAttachment[];
+        replyToMsgId?: string | null;
+    };
+    capabilities?: ConnectorCapabilities;
+    systemPrompt?: SystemAreas;
+    turnContext?: ContextFact[];
+    agentId?: string;
+    presetId?: string;
+    signal?: AbortSignal;
+    prepareAttachments?(m: AttachmentMaterializer): Promise<StoredAttachment[] | ConvMessage[]>;
 }
-export interface ReplyPayload {
+export type TurnEvent = {
+    kind: 'delta';
+    text: string;
+} | {
+    kind: 'reasoning';
+    text: string;
+} | {
+    kind: 'segment';
+} | {
+    kind: 'answer';
     text: string | null;
     reasoning: string | null;
-    suggestions: string[] | null;
-}
-export interface ReplyChannel {
-    update(text: string): void;
-    updateReasoning?(acc: string): void;
-    segment(): void;
-    finish(r: ReplyPayload): Promise<string | null>;
+} | {
+    kind: 'usage';
+    tokensIn: number | null;
+    tokensOut: number | null;
+    presetId: string | null;
+    stopReason: string | null;
+} | {
+    kind: 'error';
+    message: string;
+} | {
+    kind: 'suggestions';
+    items: string[];
+} | {
+    kind: 'title';
+    text: string;
+};
+export interface TurnSink {
+    emit(event: TurnEvent): void;
+    done(): Promise<void>;
 }
 export interface Connector {
     id: string;
-    reply(chatId: string, ctx: ReplyContext): ReplyChannel;
-    recordAssistant(m: {
-        parentMsgId: string | null;
-        botMsgId: string | null;
-        text: string;
-        reasoning: string | null;
-    }): Promise<void>;
+    open(envelope: TurnEnvelope, msgId: string): TurnSink;
+    bindMessage?(envelope: TurnEnvelope, msgId: string, externalId: string): Promise<void>;
 }
 export interface GatePolicy {
     agentId?: string;
-    accessPassword: string;
     triggerPrefix: string;
     replyWindow: number;
 }

package/dist/plugin-hooks.d.ts

@@ -1,6 +1,7 @@
 import type { EntityManager } from '@mikro-orm/core';
 import type { z } from 'zod';
-import type { ColumnType, ColumnConversion } from '@coffer-org/sdk/fields';
+import type { ColumnType, ColumnConversion, LayoutEl } from '@coffer-org/sdk/fields';
+import type { LayoutInput } from '@coffer-org/sdk/materialize/decl';
 import { type Logger } from '@coffer-org/sdk/logger';
 export type { BackgroundTask } from './background-scheduler.ts';
 export interface TableOps {
@@ -60,6 +61,15 @@ export type PluginStreamAction = (body: Record<string, unknown>, ctx: {
     emit: (event: string, data: unknown) => void;
     signal: AbortSignal;
 }) => Promise<void>;
+export interface PrivateTableDef {
+    name: string;
+    fields: LayoutEl[];
+    unique?: string[][];
+}
+export type PrivateTableDefInput = Omit<PrivateTableDef, 'fields'> & {
+    fields: LayoutInput;
+};
+export declare function definePrivateTable(t: PrivateTableDefInput): PrivateTableDef;
 export interface PluginHooks {
     migrations?: Migration[];
     seed?: Seed[];
@@ -70,5 +80,32 @@ export interface PluginHooks {
     actions?: Record<string, PluginAction>;
     userActions?: Record<string, PluginUserAction>;
     streamActions?: Record<string, PluginStreamAction>;
+    http?: PluginHttpMount[];
+    tables?: PrivateTableDef[];
 }
 export declare const pluginHooks: Record<string, PluginHooks>;
+export interface PluginHttpRequest {
+    method: string;
+    path: string;
+    url: string;
+    headers: Record<string, string>;
+    body: string;
+    user: {
+        id: number;
+        login: string;
+        role: AuthRole;
+    };
+}
+export interface PluginHttpResponse {
+    status: number;
+    headers?: Record<string, string>;
+    body?: string;
+}
+export interface PluginHttpMount {
+    prefix: string;
+    methods: string[];
+    auth: 'member' | 'admin' | 'token';
+    body?: 'text' | 'none';
+    wellKnown?: string;
+    handle(req: PluginHttpRequest): Promise<PluginHttpResponse>;
+}

package/dist/plugin-hooks.js

@@ -1,3 +1,4 @@
+import { materializeDef } from '@coffer-org/sdk/materialize/pipeline';
 import { getLogger } from '@coffer-org/sdk/logger';
 export function pluginCtx(id, em, signal) {
     return { em, log: getLogger(id), ...(signal ? { signal } : {}) };
@@ -10,4 +11,7 @@ export class HttpError extends Error {
         this.name = 'HttpError';
     }
 }
+export function definePrivateTable(t) {
+    return materializeDef(t);
+}
 export const pluginHooks = {};

package/dist/plugin-http-mounts.d.ts

@@ -0,0 +1,18 @@
+import type { FastifyInstance, FastifyRequest } from 'fastify';
+import type { AuthRole, PluginHooks, PluginHttpMount } from './plugin-hooks.ts';
+export interface MountEntry {
+    pluginId: string;
+    mount: PluginHttpMount;
+}
+export declare function collectHttpMounts(hooks: Record<string, PluginHooks>): MountEntry[];
+export declare function customMethodsOf(entries: MountEntry[]): string[];
+export declare function registerTextBodyParsers(app: FastifyInstance): void;
+export interface MountDeps {
+    disabledSet: () => Promise<Set<string>>;
+    resolveUser: (req: FastifyRequest) => Promise<{
+        id: number;
+        login: string;
+        role: AuthRole;
+    } | null>;
+}
+export declare function registerPluginHttpMounts(app: FastifyInstance, entries: MountEntry[], deps: MountDeps): void;

package/dist/plugin-http-mounts.js

@@ -0,0 +1,94 @@
+const RESERVED = ['/api', '/mcp', '/health', '/uploads', '/.well-known', '/assets'];
+const DEFAULT_METHODS = new Set(['GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'PATCH']);
+export function collectHttpMounts(hooks) {
+    const out = [];
+    const owner = new Map();
+    for (const [pluginId, h] of Object.entries(hooks)) {
+        for (const mount of h.http ?? []) {
+            const prefix = mount.prefix.replace(/\/+$/, '');
+            if (!prefix.startsWith('/') || prefix === '') {
+                throw new Error(`[plugin-http] ${pluginId}: prefix must be absolute, got '${mount.prefix}'`);
+            }
+            if (RESERVED.some((r) => prefix === r || prefix.startsWith(r + '/'))) {
+                throw new Error(`[plugin-http] ${pluginId}: prefix '${prefix}' is reserved for the core`);
+            }
+            const other = owner.get(prefix);
+            if (other)
+                throw new Error(`[plugin-http] prefix '${prefix}' is declared by both ${other} and ${pluginId}`);
+            owner.set(prefix, pluginId);
+            out.push({ pluginId, mount: { ...mount, prefix, methods: mount.methods.map((m) => m.toUpperCase()) } });
+        }
+    }
+    return out;
+}
+export function customMethodsOf(entries) {
+    const seen = new Set();
+    for (const e of entries)
+        for (const m of e.mount.methods)
+            if (!DEFAULT_METHODS.has(m))
+                seen.add(m);
+    return [...seen];
+}
+export function registerTextBodyParsers(app) {
+    const asText = (_req, body, done) => done(null, body);
+    for (const type of ['text/calendar', 'text/xml', 'application/xml', 'text/plain', 'application/octet-stream']) {
+        if (!app.hasContentTypeParser(type))
+            app.addContentTypeParser(type, { parseAs: 'string' }, asText);
+    }
+}
+function flatHeaders(raw) {
+    const out = {};
+    for (const [k, v] of Object.entries(raw)) {
+        if (v === undefined)
+            continue;
+        out[k.toLowerCase()] = Array.isArray(v) ? v.join(', ') : String(v);
+    }
+    return out;
+}
+export function registerPluginHttpMounts(app, entries, deps) {
+    for (const method of customMethodsOf(entries))
+        app.addHttpMethod(method, { hasBody: true });
+    for (const { pluginId, mount } of entries) {
+        const allow = mount.methods.join(', ');
+        const handler = async (req, reply) => {
+            if ((await deps.disabledSet()).has(pluginId))
+                return reply.code(404).send({ error: 'not_found' });
+            if (!mount.methods.includes(req.method.toUpperCase())) {
+                return reply.code(405).header('allow', allow).send();
+            }
+            const user = req.user ?? (await deps.resolveUser(req));
+            if (!user) {
+                if (mount.auth === 'token')
+                    reply.header('www-authenticate', 'Basic realm="Coffer"');
+                return reply.code(401).send({ error: 'unauthorized' });
+            }
+            if (mount.auth === 'admin' && user.role !== 'admin')
+                return reply.code(403).send({ error: 'forbidden' });
+            const full = req.url.split('?')[0];
+            const below = full.slice(mount.prefix.length);
+            const body = mount.body === 'none' ? '' : typeof req.body === 'string' ? req.body : req.body ? JSON.stringify(req.body) : '';
+            const res = await mount.handle({
+                method: req.method.toUpperCase(),
+                path: below === '' ? '/' : below,
+                url: req.url,
+                headers: flatHeaders(req.headers),
+                body,
+                user: { id: user.id, login: user.login, role: user.role },
+            });
+            reply.code(res.status);
+            for (const [k, v] of Object.entries(res.headers ?? {}))
+                reply.header(k, v);
+            return reply.send(res.body ?? '');
+        };
+        const verbs = [...new Set([...mount.methods, ...DEFAULT_METHODS])];
+        app.route({ method: verbs, url: mount.prefix, handler });
+        app.route({ method: verbs, url: `${mount.prefix}/*`, handler });
+        if (mount.wellKnown) {
+            app.route({
+                method: verbs,
+                url: `/.well-known/${mount.wellKnown}`,
+                handler: async (_req, reply) => reply.code(301).header('location', `${mount.prefix}/`).send(),
+            });
+        }
+    }
+}

package/dist/plugin-runtime.d.ts

@@ -1,14 +1,18 @@
+import type { EntitySchema } from '@mikro-orm/core';
 import { type Registry } from '@coffer-org/sdk/compose';
 import type { PluginManifest } from '@coffer-org/sdk/plugin';
+import { type PluginHooks } from './plugin-hooks.ts';
 export declare function getPlugins(): Promise<PluginManifest[]>;
 export declare function readDisabled(): Promise<Set<string>>;
 export declare function getDisabled(): Promise<Set<string>>;
 export declare function getPluginSettings(groupId: string): Promise<Record<string, unknown>>;
 export declare function requireSettings<K extends string>(pluginId: string, keys: readonly K[]): Promise<Record<K, string>>;
+export declare function privateTableEntities(plugins: PluginManifest[], hooks: Record<string, PluginHooks>): EntitySchema[];
 export declare function initStorage(): Promise<Set<string>>;
 export declare function initPlugins(): Promise<Registry>;
 export declare function teardownPlugins(): Promise<void>;
 export declare function teardownPlugin(id: string): Promise<void>;
+export declare function pluginTables(p: PluginManifest, hooks?: Record<string, PluginHooks>): string[];
 export declare function purgePluginData(p: PluginManifest, actor: string): Promise<void>;
 export declare function filterEnabled<T extends {
     id: string;

package/dist/plugin-runtime.js

@@ -2,7 +2,7 @@ import { composeRegistry } from '@coffer-org/sdk/compose';
 import { getLogger } from '@coffer-org/sdk/logger';
 import { initDb, getOrm, getEm } from "./db.js";
 import { syncSchema } from "./schema-sync.js";
-import { systemEntities, buildPluginEntities, shelfTableName } from "./entity-schema.js";
+import { systemEntities, buildPluginEntities, buildPrivateTableEntity, shelfTableName, privateTableName, } from "./entity-schema.js";
 import { pluginHooks, pluginCtx, HttpError } from "./plugin-hooks.js";
 import { discoverPlugins, loadServerHooks } from "./plugin-discovery.js";
 import { selectRows } from "./read-rows.js";
@@ -78,6 +78,9 @@ async function seedPluginRows() {
     }
     await fork.flush();
 }
+export function privateTableEntities(plugins, hooks) {
+    return plugins.flatMap((p) => (hooks[p.id]?.tables ?? []).map((t) => buildPrivateTableEntity(p.id, t)));
+}
 export async function initStorage() {
     await initDb(systemEntities);
     await runSystemMigrations(getEm().fork());
@@ -92,10 +95,10 @@ export async function initStorage() {
     const hooks = await loadServerHooks();
     await runMigrations({
         em: getEm().fork(),
-        plugins: active.map((p) => ({ id: p.id, tables: pluginTables(p) })),
+        plugins: active.map((p) => ({ id: p.id, tables: pluginTables(p, hooks) })),
         hooks,
     });
-    const pluginEntities = buildPluginEntities(active);
+    const pluginEntities = [...buildPluginEntities(active), ...privateTableEntities(active, hooks)];
     await assertSafeRequired(getEm().fork(), pluginEntities);
     if (pluginEntities.length)
         getOrm().discoverEntity(pluginEntities);
@@ -175,16 +178,17 @@ function pluginShelves(p) {
         ...(p.libraryShelves ?? []).map((m) => ({ library: m.library, shelf: m.shelf })),
     ];
 }
-function pluginTables(p) {
+export function pluginTables(p, hooks) {
     return [
         ...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}`] : []),
+        ...(hooks?.[p.id]?.tables ?? []).map((t) => privateTableName(p.id, t.name)),
     ];
 }
 export async function purgePluginData(p, actor) {
     await teardownPlugin(p.id);
-    const tables = pluginTables(p);
+    const tables = pluginTables(p, pluginHooks);
     const conn = getEm().fork().getConnection();
     for (const t of tables) {
         await conn.execute(`DROP TABLE IF EXISTS "${t}"`);

package/dist/plugins-api.d.ts

@@ -1,15 +1,21 @@
 import type { FastifyInstance } from 'fastify';
 import type { PluginManifest } from '@coffer-org/sdk/plugin';
 import type { PluginAssetRecord } from './plugin-discovery.ts';
+export interface PluginLabelEntry {
+    id: string;
+    label: string;
+}
 export interface PluginListEntry {
     id: string;
+    label: string;
+    description: string;
     installedVersion: string;
     latestVersion: string | null;
     packageName: string | null;
     dependsOn: string[];
     enabled: boolean;
-    libraries: string[];
-    extends: string[];
+    libraries: PluginLabelEntry[];
+    extends: PluginLabelEntry[];
     hasSettings: boolean;
     schema?: string;
     web?: string;

package/dist/plugins-api.js

@@ -11,13 +11,15 @@ export async function buildPluginListResponse(plugins, assets, disabled, withUpd
         const a = assetById.get(p.id);
         return {
             id: p.id,
+            label: p.label,
+            description: p.description,
             installedVersion: a?.version ?? p.version,
             latestVersion: withUpdates && a && !a.local ? await checkLatestVersion(a.packageName, { force: forceUpdates }) : null,
             packageName: a?.packageName ?? null,
             dependsOn: p.dependsOn,
             enabled: !disabled.has(p.id),
-            libraries: (p.libraries ?? []).map((v) => v.meta.id),
-            extends: (p.extends_ ?? []).map((e) => e.id),
+            libraries: (p.libraries ?? []).map((v) => ({ id: v.meta.id, label: v.meta.label })),
+            extends: (p.extends_ ?? []).map((e) => ({ id: e.id, label: e.label })),
             hasSettings: Boolean(p.settings && p.settings.fields.length > 0),
             schema: a?.schema,
             web: a?.web,

package/dist/records-api.js

@@ -1,3 +1,5 @@
+import { isJsonArrayStored } from '@coffer-org/sdk/fields';
+import { raw } from '@mikro-orm/core';
 import { fieldMap, textSearchKeys, titleKey, recordTitle, listKeys, storageColumnsFor, magnitudeSub, resolveColumnKey, } from '@coffer-org/sdk/shelf';
 import { tokenize, matchScoreFolded, foldText } from '@coffer-org/sdk/search';
 import { getActiveRegistry, getShelf, getExtendsFor } from "./registry-context.js";
@@ -97,7 +99,7 @@ function resolveFilterKey(m, fm, k) {
     const direct = fm[k];
     if (direct) {
         if (!direct.columns)
-            return { column: k, type: direct.column };
+            return { column: k, type: direct.column, json: isJsonArrayStored(direct) };
         const sub = magnitudeSub(direct);
         if (sub === undefined)
             throw new FilterError(`${m.library}/${m.shelf}: '${k}' is a composite with no stored part — it owns no column to filter on`);
@@ -110,14 +112,24 @@ function resolveFilterKey(m, fm, k) {
         throw new FilterError(`${m.library}/${m.shelf}: '${k}' names no part of composite '${owner.key}' (parts: ${Object.keys(owner.field.columns).join(', ')})`);
     return { column: k, type: owner.field.columns[owner.sub] };
 }
+function jsonMemberClause(column, value) {
+    const col = `"${column.replace(/"/g, '""')}"`;
+    return {
+        [raw(`(json_valid(${col}) AND EXISTS (SELECT 1 FROM json_each(${col}) WHERE CAST(value AS TEXT) = ?))`, [value])]: 1,
+    };
+}
 function buildWhere(m, filterParams) {
-    const where = {};
+    let where = {};
     const fm = fieldMap(m.fields);
     for (const [k, v] of Object.entries(filterParams)) {
         if (k === 'id' || v === undefined)
             continue;
         const target = resolveFilterKey(m, fm, k);
-        if (target)
+        if (!target)
+            continue;
+        if (target.json)
+            where = { ...where, ...jsonMemberClause(target.column, String(v)) };
+        else
             where[target.column] = coerceFilter(String(v), target.type);
     }
     if (filterParams['id']) {

package/dist/settings-write.d.ts

@@ -5,11 +5,10 @@ export interface SettingsFieldInfo {
     key: string;
     kind: string;
     label?: string;
-    required: boolean;
     options?: string[];
 }
 export declare function describeSettingsFields(fields: LayoutEl[]): SettingsFieldInfo[];
-export declare function buildSettingsBody(groupId: string, fields: LayoutEl[], incoming: Record<string, unknown>, existing: Record<string, unknown>, label?: string): Record<string, unknown>;
+export declare function buildSettingsBody(groupId: string, fields: LayoutEl[], incoming: Record<string, unknown>, existing: Record<string, unknown>, label: string): Record<string, unknown>;
 export declare function writePluginSettings(em: EntityManager, groupId: string, incoming: Record<string, unknown>, actor: string, pluginsOverride?: PluginManifest[]): Promise<Record<string, unknown>>;
 export declare function listSettings(pluginsOverride?: PluginManifest[]): Promise<{
     group: string;

package/dist/settings-write.js

@@ -9,11 +9,10 @@ export function describeSettingsFields(fields) {
         key,
         kind: f.kind,
         label: f.label,
-        required: f.required === true,
         ...(f.options ? { options: f.options.map((o) => o.value) } : {}),
     }));
 }
-function settingsShelf(groupId, fields, label = `${groupId}.plugin.label`) {
+function settingsShelf(groupId, fields, label) {
     return { library: '_settings', shelf: groupId, label, fields };
 }
 export function buildSettingsBody(groupId, fields, incoming, existing, label) {

package/dist/system-settings.js

@@ -20,7 +20,6 @@ export const SYSTEM_SETTINGS = defineSettings({
             ],
         }),
         agent_id: field.string({ label: 'core.settings.agent_id', strict: true, noSearch: true }),
-        access_password: field.password({ label: 'core.settings.access_password' }),
         trigger_prefix: field.string({ label: 'core.settings.trigger_prefix' }),
         reply_window: field.int({ label: 'core.settings.reply_window', default: 1800 }),
     },

package/dist/temporal.js

@@ -1,4 +1,4 @@
-import { fieldMap } from '@coffer-org/sdk/shelf';
+import { fieldEntries, storageColumns } from '@coffer-org/sdk/shelf';
 export function dtStringToDate(s) {
     return new Date(`${s}:00Z`);
 }
@@ -8,8 +8,13 @@ export function dateToDtString(d) {
         `T${p(d.getUTCHours())}:${p(d.getUTCMinutes())}`);
 }
 function datetimeKeysAt(fields) {
-    const fm = fieldMap(fields);
-    return Object.keys(fm).filter((k) => fm[k]?.column === 'datetime');
+    const out = [];
+    for (const [key, fm] of fieldEntries(fields)) {
+        for (const [col, type] of storageColumns(key, fm))
+            if (type === 'datetime')
+                out.push(col);
+    }
+    return out;
 }
 export function encodeTemporalAt(fields, row) {
     const out = { ...row };