@coffer-org/server 7.2.0 → 7.4.0

package/dist/index.js

@@ -15,10 +15,12 @@ import { NotFoundError } from "./mutate.js";
 import { httpErrorFor, registerErrorHandler } from "./http-errors.js";
 import { resolveEmbed } from "./embed.js";
 import { resolveWithinHome, filterSort, listDir } from "./fs-list.js";
-import { initPlugins, teardownPlugins, readDisabled, purgePluginData, getPluginSettings, getPlugins, } from "./plugin-runtime.js";
+import { initPlugins, teardownPlugins, readDisabled, getDisabled, purgePluginData, getPluginSettings, getPlugins, } from "./plugin-runtime.js";
 import { registerPluginsApi } from "./plugins-api.js";
 import { orchestratorDiagnostics } from "./orchestrator/index.js";
+import { pluginHooks } from "./plugin-hooks.js";
 import { registerPluginUserApi, registerPluginAdminApi } from "./plugin-user-api.js";
+import { collectHttpMounts, registerPluginHttpMounts, registerTextBodyParsers } from "./plugin-http-mounts.js";
 import { registerAuthApi, resolveRequestUser, requireAdmin, PUBLIC_API_PATHS } from "./auth-api.js";
 import { registerMcpHttp } from "./mcp-http.js";
 import { registerOAuthApi } from "./oauth-api.js";
@@ -71,6 +73,7 @@ app.addHook('onResponse', async (req, reply) => {
 });
 await app.register(cors, { origin: true });
 await app.register(multipart, { limits: { fileSize: 25 * 1024 * 1024 } });
+registerTextBodyParsers(app);
 await app.register(fastifyStatic, { root: UPLOADS, prefix: '/uploads/' });
 app.addHook('onSend', async (req, reply, payload) => {
     if (req.url.startsWith('/uploads/')) {
@@ -327,6 +330,10 @@ app.put('/api/settings/:id', (req, reply) => {
 });
 registerPluginAdminApi(app, requireAdmin);
 registerPluginUserApi(app);
+const httpMounts = collectHttpMounts(pluginHooks);
+registerPluginHttpMounts(app, httpMounts, { disabledSet: getDisabled, resolveUser: resolveRequestUser });
+if (httpMounts.length)
+    app.log.info(`plugin http mounts: ${httpMounts.map((m) => `${m.pluginId}${m.mount.prefix}`).join(', ')}`);
 app.get('/api/fs/list', async (req, reply) => {
     const home = homedir();
     const q = req.query;

package/dist/mcp-contract/schema.d.ts

@@ -35,7 +35,6 @@ export interface FieldInfo {
     key: string;
     kind: string;
     prim: string;
-    required: boolean;
     agent?: string;
     relation?: {
         library: string;

package/dist/mcp-contract/schema.js

@@ -52,7 +52,6 @@ export function flattenFields(items) {
         key,
         kind: t.kind,
         prim: t.prim,
-        required: t.required,
         ...(t.agent ? { agent: t.agent } : {}),
         ...(t.relation ? { relation: t.relation } : {}),
         ...(t.options ? { options: t.options } : {}),
@@ -69,7 +68,6 @@ export function flattenFields(items) {
                 key: it.key,
                 kind: 'group',
                 prim: 'group',
-                required: it.required === true,
                 ...(it.agent ? { agent: it.agent } : {}),
                 ...(it.multiple ? { multiple: true } : {}),
                 fields: flattenFields(it.fields),

package/dist/mcp-http.js

@@ -1,14 +1,18 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { collectMcpTools, resolveRagDeps, buildDomainSections, buildMcpInstructions, siteSection, } from "./mcp-tools.js";
+import { collectMcpTools, resolveRagDeps, buildDomainAreas, buildMcpInstructions, siteSection } from "./mcp-tools.js";
+import { assembleSystem, ALL_PRESENT } from "./orchestrator/system-areas.js";
 import { configuredPublicUrl } from "./public-url.js";
 import { getLogger } from "./log.js";
 const log = getLogger('mcp-http');
 export async function buildMcpServer(role, actor) {
     const rag = await resolveRagDeps();
-    const tools = (await collectMcpTools({ rag, includeAdmin: role === 'admin', actor })).filter((t) => role === 'admin' || t.role === 'member');
+    const tools = await collectMcpTools({ rag, role, actor });
     const site = await siteSection(await configuredPublicUrl());
-    const sections = [...(await buildDomainSections()), ...(site ? [site] : [])];
+    const areas = await buildDomainAreas();
+    if (site)
+        areas['channel'] = [site];
+    const sections = assembleSystem(areas, ALL_PRESENT);
     const server = new McpServer({ name: 'coffer', version: '1.0.0' }, { instructions: buildMcpInstructions(sections) });
     const registerTool = server.registerTool.bind(server);
     for (const t of tools) {

package/dist/mcp-tools.d.ts

@@ -6,6 +6,7 @@ import { type AuthRole, type PluginHooks } from './plugin-hooks.ts';
 import { type Condition } from '@coffer-org/sdk/condition';
 import { type AgentMeta } from '@coffer-org/sdk/library';
 import { type RagHit } from './rag-search.ts';
+import type { SystemAreas } from './orchestrator/system-areas.ts';
 export interface McpToolDef {
     server: string;
     bareName: string;
@@ -21,9 +22,9 @@ export interface RagDeps {
 }
 export declare function formatHits(hits: RagHit[]): string;
 export declare function resolveRagDeps(): Promise<RagDeps | null>;
-export declare function collectMcpTools(opts?: {
+export declare function collectMcpTools(opts: {
+    role: AuthRole;
     rag?: RagDeps | null;
-    includeAdmin?: boolean;
     actor?: string;
 }): Promise<McpToolDef[]>;
 export declare function collectPluginInstructions(hooks?: Record<string, PluginHooks>, emFactory?: () => EntityManager): Promise<{
@@ -73,7 +74,7 @@ export declare function collectLibraryPurposes(reg?: {
     }[];
 }, locales?: LocaleResolver): LibraryPurpose[];
 export declare function siteSection(siteUrl: string): Promise<string | null>;
-export declare function buildDomainSections(locales?: LocaleResolver): Promise<string[]>;
+export declare function buildDomainAreas(locales?: LocaleResolver): Promise<SystemAreas>;
 export interface StarterHint {
     id: string;
     text: string;

package/dist/mcp-tools.js

@@ -47,7 +47,7 @@ export async function resolveRagDeps() {
         return null;
     return { embeddingApiKey };
 }
-export async function collectMcpTools(opts = {}) {
+export async function collectMcpTools(opts) {
     const out = [];
     const client = new LocalClient();
     const locales = await loadComposedLocales();
@@ -202,54 +202,52 @@ export async function collectMcpTools(opts = {}) {
             },
         });
     }
-    if (opts.includeAdmin) {
-        const actor = opts.actor ?? 'mcp';
-        out.push({
-            server: 'coffer',
-            bareName: 'list_settings',
-            httpName: 'list_settings',
-            description: "List every settings group (the instance's own `system` group and each plugin's): 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. group — the settings group id (e.g. "system", "claude-agent"); fields — only the settings to change (see list_settings). Send real secret values; the masked placeholder (********) is treated as unchanged.',
-            inputSchema: { group: z.string(), fields: z.record(z.string(), z.unknown()) },
-            scope: 'settings',
-            role: 'admin',
-            handler: async (args) => {
-                try {
-                    const row = await writePluginSettings(getEm().fork(), args.group, 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(`No settings group '${String(args.group)}'.`);
-                    return fail(`Error: ${e.message}`);
+    const actor = opts.actor ?? 'mcp';
+    out.push({
+        server: 'coffer',
+        bareName: 'list_settings',
+        httpName: 'list_settings',
+        description: "List every settings group (the instance's own `system` group and each plugin's): 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. group — the settings group id (e.g. "system", "claude-agent"); fields — only the settings to change (see list_settings). Send real secret values; the masked placeholder (********) is treated as unchanged.',
+        inputSchema: { group: z.string(), fields: z.record(z.string(), z.unknown()) },
+        scope: 'settings',
+        role: 'admin',
+        handler: async (args) => {
+            try {
+                const row = await writePluginSettings(getEm().fork(), args.group, 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')}`);
                 }
-            },
-        });
-    }
-    return out;
+                if (e instanceof NotFoundError)
+                    return fail(`No settings group '${String(args.group)}'.`);
+                return fail(`Error: ${e.message}`);
+            }
+        },
+    });
+    return opts.role === 'admin' ? out : out.filter((t) => t.role === 'member');
 }
 export async function collectPluginInstructions(hooks = pluginHooks, emFactory = () => getEm().fork()) {
     const out = [];
@@ -316,44 +314,46 @@ export async function siteSection(siteUrl) {
     const site = await frontendInstructions(siteUrl);
     return site ? `## web\n${site}` : null;
 }
-export async function buildDomainSections(locales) {
+const DATA_MODEL = '## Data model\n' +
+    'Library (top-level area) → shelf (a kind of record, e.g. things/item) → record (addressed library/shelf/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 shelf's records, shown only when a " +
+    'condition holds (the "when …" notes below); in a fetched record they sit under `_extends`. ' +
+    'Read: list_libraries → describe_shelf → list_records/get_record. Write: create_record/update_record (call describe_shelf first); ' +
+    'delete_record moves a record to reversible trash — do not blank fields. Before editing, read the complete record and patch only requested fields. ' +
+    'For duplicates, read both records completely, compare fields/collections/extends/attachments, recommend the less complete record for trash, and offer a field-by-field merge first. ' +
+    'Use list_trash and restore_record for recovery; purge_record is irreversible and requires explicit confirmation. ' +
+    'Each library below names what it holds and when to use it — pick the right one before searching. ' +
+    'A single-record shelf holds exactly one document — read it directly, do not search the shelf.';
+function renderLibrary(v) {
+    let s = v.name === v.id ? `### ${v.id} — ${v.agent}` : `### ${v.id} ("${v.name}") — ${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.agent.replace(/\s*\n\s*/g, ' ')}`;
+                })
+                    .join('\n');
+    }
+    return s;
+}
+export async function buildDomainAreas(locales) {
     const i18n = locales ?? (await loadComposedLocales());
-    const libraries = collectLibraryPurposes(undefined, i18n);
-    let overview = null;
-    if (libraries.length) {
-        const blocks = libraries.map((v) => {
-            let s = v.name === v.id ? `### ${v.id} — ${v.agent}` : `### ${v.id} ("${v.name}") — ${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.agent.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 areas = { root: [DATA_MODEL] };
+    for (const v of collectLibraryPurposes(undefined, i18n)) {
+        areas[`library:${v.id}`] = [renderLibrary(v)];
+    }
+    for (const s of collectSingleShelves()) {
+        areas[`shelf:${s.library}/${s.shelf}`] = [
+            `### ${s.library}/${s.shelf} — single record: read it directly, do not search the shelf. ${s.agent.replace(/\s*\n\s*/g, ' ')}`,
+        ];
+    }
+    for (const { id, instructions } of await collectPluginInstructions()) {
+        areas[`plugin:${id}`] = [`## ${id}\n${instructions}`];
     }
-    const singles = collectSingleShelves();
-    const singleSection = singles.length
-        ? '## Single-record shelves (one document each — read the record, do not search the shelf)\n\n' +
-            singles.map((s) => `- ${s.library}/${s.shelf}: ${s.agent.replace(/\s*\n\s*/g, ' ')}`).join('\n')
-        : null;
-    const dataModel = '## Data model\n' +
-        'Library (top-level area) → shelf (a kind of record, e.g. things/item) → record (addressed library/shelf/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 shelf's records, shown only when a " +
-        'condition holds (the "when …" notes below); in a fetched record they sit under `_extends`. ' +
-        'Read: list_libraries → describe_shelf → list_records/get_record. Write: create_record/update_record (call describe_shelf first); ' +
-        'delete_record moves a record to reversible trash — do not blank fields. Before editing, read the complete record and patch only requested fields. ' +
-        'For duplicates, read both records completely, compare fields/collections/extends/attachments, recommend the less complete record for trash, and offer a field-by-field merge first. ' +
-        'Use list_trash and restore_record for recovery; purge_record is irreversible and requires explicit confirmation.';
-    const rules = (await collectPluginInstructions()).map(({ id, instructions }) => `## ${id}\n${instructions}`);
-    return [dataModel, ...(overview ? [overview] : []), ...(singleSection ? [singleSection] : []), ...rules];
+    return areas;
 }
 export const CORE_STARTER_HINT = 'what this Coffer instance itself holds — which libraries are present and what kinds of ' +
     'questions the stored data can answer';

package/dist/media/image.d.ts

@@ -0,0 +1,23 @@
+export interface ImageTarget {
+    maxEdge: number;
+    maxPixels?: number;
+    maxBytes: number;
+    encode: readonly string[];
+}
+export interface ImageFacts {
+    mime: string;
+    width: number;
+    height: number;
+    bytes: number;
+}
+export interface NormalizedImage {
+    bytes: Buffer;
+    mime: string;
+    width: number;
+    height: number;
+    source: ImageFacts;
+    changed: boolean;
+}
+export declare class ImageNormalizeError extends Error {
+}
+export declare function normalizeImage(bytes: Buffer, target: ImageTarget): Promise<NormalizedImage>;

package/dist/media/image.js

@@ -0,0 +1,103 @@
+import sharp from 'sharp';
+export class ImageNormalizeError extends Error {
+}
+const MIME_BY_FORMAT = {
+    jpeg: 'image/jpeg',
+    jpg: 'image/jpeg',
+    png: 'image/png',
+    webp: 'image/webp',
+    gif: 'image/gif',
+    avif: 'image/avif',
+    tiff: 'image/tiff',
+    heif: 'image/heif',
+};
+const QUALITY_LADDER = [85, 72, 58, 44];
+const MAX_ATTEMPTS = 6;
+const QUALITY_CAN_CLOSE = 2;
+function fit(width, height, maxEdge, maxPixels) {
+    let scale = Math.min(1, maxEdge / Math.max(width, height));
+    if (maxPixels)
+        scale = Math.min(scale, Math.sqrt(maxPixels / (width * height)));
+    return scaleTo(width, height, scale);
+}
+function scaleTo(width, height, scale) {
+    return {
+        width: Math.max(1, Math.floor(width * scale)),
+        height: Math.max(1, Math.floor(height * scale)),
+    };
+}
+function pickEncoding(target, hasAlpha) {
+    const accepts = (mime) => target.encode.includes(mime);
+    const order = hasAlpha ? ['image/webp', 'image/png', 'image/jpeg'] : ['image/jpeg', 'image/webp', 'image/png'];
+    for (const mime of order)
+        if (accepts(mime))
+            return mime;
+    throw new ImageNormalizeError(`the agent takes back none of the encodings this image could be produced in: ${target.encode.join(', ') || '(none declared)'}`);
+}
+function encode(pipeline, mime, quality) {
+    switch (mime) {
+        case 'image/jpeg':
+            return pipeline.jpeg({ quality, mozjpeg: true }).toBuffer();
+        case 'image/webp':
+            return pipeline.webp({ quality }).toBuffer();
+        case 'image/png':
+            return pipeline.png({ compressionLevel: 9, palette: true, quality }).toBuffer();
+        default:
+            throw new ImageNormalizeError(`Unsupported target encoding: ${mime}`);
+    }
+}
+export async function normalizeImage(bytes, target) {
+    let meta;
+    try {
+        meta = await sharp(bytes).metadata();
+    }
+    catch (err) {
+        throw new ImageNormalizeError(`Not a decodable image: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const format = meta.format ? MIME_BY_FORMAT[meta.format] : undefined;
+    const swap = (meta.orientation ?? 0) >= 5;
+    const width = swap ? meta.height : meta.width;
+    const height = swap ? meta.width : meta.height;
+    if (!format || !width || !height)
+        throw new ImageNormalizeError('Image has no readable format or dimensions.');
+    const source = { mime: format, width, height, bytes: bytes.length };
+    const target1 = fit(width, height, target.maxEdge, target.maxPixels);
+    const fitsNow = target.encode.includes(format) &&
+        bytes.length <= target.maxBytes &&
+        target1.width === width &&
+        target1.height === height;
+    if (fitsNow)
+        return { bytes, mime: format, width, height, source, changed: false };
+    const mime = pickEncoding(target, meta.hasAlpha === true);
+    const flatten = meta.hasAlpha === true && mime === 'image/jpeg';
+    let dims = target1;
+    let qualityStep = 0;
+    let last;
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+        let pipeline = sharp(bytes).rotate();
+        if (flatten)
+            pipeline = pipeline.flatten({ background: '#ffffff' });
+        pipeline = pipeline.resize({ ...dims, fit: 'inside', withoutEnlargement: true });
+        const quality = QUALITY_LADDER[Math.min(qualityStep, QUALITY_LADDER.length - 1)];
+        last = await encode(pipeline, mime, quality);
+        if (last.length <= target.maxBytes) {
+            const out = await sharp(last).metadata();
+            return {
+                bytes: last,
+                mime,
+                width: out.width ?? dims.width,
+                height: out.height ?? dims.height,
+                source,
+                changed: true,
+            };
+        }
+        if (last.length <= target.maxBytes * QUALITY_CAN_CLOSE && qualityStep < QUALITY_LADDER.length - 1) {
+            qualityStep += 1;
+        }
+        else {
+            const shrink = Math.sqrt(target.maxBytes / last.length) * 0.9;
+            dims = scaleTo(dims.width, dims.height, Math.min(0.9, shrink));
+        }
+    }
+    throw new ImageNormalizeError(`Could not bring the image within ${target.maxBytes} bytes: ${last?.length ?? source.bytes} bytes after ${MAX_ATTEMPTS} attempts.`);
+}

package/dist/media/index.d.ts

@@ -0,0 +1 @@
+export { normalizeImage, ImageNormalizeError, type ImageTarget, type ImageFacts, type NormalizedImage, } from './image.ts';

package/dist/media/index.js

@@ -0,0 +1 @@
+export { normalizeImage, ImageNormalizeError, } from "./image.js";

package/dist/migrations.js

@@ -394,7 +394,7 @@ export function makeTable(em, table, record) {
 export async function renameSystemShelfKey(em) {
     await makeTable(em, '_embeddings').renameColumn('type', 'shelf_key');
 }
-const LEGACY_ORCHESTRATOR_FIELDS = ['agent_id', 'access_password', 'trigger_prefix', 'reply_window'];
+const LEGACY_ORCHESTRATOR_FIELDS = ['agent_id', 'trigger_prefix', 'reply_window'];
 export const SYSTEM_MIGRATIONS = [
     {
         name: 'embeddings-shelf-key',

package/dist/mutate.js

@@ -1,7 +1,6 @@
 import { serialize } from '@mikro-orm/core';
 import { buildZodObject, buildZodObjectPartial, fieldEntries, collectionGroups } 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 { selectRows } from "./read-rows.js";
 import { normalizeFileFields, dropUnchangedFileFields, touchesFileFields } from "./file-fields.js";
@@ -190,20 +189,6 @@ export async function updateRecord(m, entityName, id, input, ctx, afterBase) {
             throw new ValidationError(fileIssues);
         const { base, collections } = splitCollections(m, { ...patchData });
         const merged = { ...existing, ...base };
-        const reqIssues = [];
-        for (const [key, f] of fieldEntries(m.fields)) {
-            if (f.required === true)
-                continue;
-            if (key.includes('__'))
-                continue;
-            if (!resolveFlag(f.required, merged))
-                continue;
-            const v = merged[key];
-            if (v == null || v === '' || (Array.isArray(v) && v.length === 0))
-                reqIssues.push({ field: key, code: 'required', path: [key] });
-        }
-        if (reqIssues.length)
-            throw new ValidationError(reqIssues);
         const storedWithMeta = hasStoredPartWork(m.fields)
             ? await readCollectionsWithMeta(tx, m, id)
             : { collections: {}, meta: {} };

package/dist/orchestrator/agent-capabilities.d.ts

@@ -1,2 +1,2 @@
-import type { AgentToolProvider, AttachmentRef } from './types.ts';
-export declare function makeAttachmentCapabilities(attachments: AttachmentRef[]): Promise<AgentToolProvider>;
+import type { AgentMediaLimits, AgentToolProvider, AttachmentRef } from './types.ts';
+export declare function makeAttachmentCapabilities(attachments: AttachmentRef[], limits: AgentMediaLimits): Promise<AgentToolProvider>;

package/dist/orchestrator/agent-capabilities.js

@@ -57,8 +57,8 @@ function fileItems(value) {
 function findTool(defs, name) {
     return defs.find((def) => def.server === 'coffer' && def.bareName === name);
 }
-export async function makeAttachmentCapabilities(attachments) {
-    const defs = await collectMcpTools();
+export async function makeAttachmentCapabilities(attachments, limits) {
+    const defs = await collectMcpTools({ role: 'member' });
     const getRecord = findTool(defs, 'get_record');
     const updateRecord = findTool(defs, 'update_record');
     const tools = [];
@@ -115,7 +115,7 @@ export async function makeAttachmentCapabilities(attachments) {
                 return inspectUpload(item['name'], {
                     ...(typeof item['mime'] === 'string' ? { mime: item['mime'] } : {}),
                     ...(typeof item['size'] === 'number' ? { size: item['size'] } : {}),
-                });
+                }, limits);
             },
         });
     }

package/dist/orchestrator/allow.d.ts

@@ -1,16 +1 @@
-import type { GatePolicy } from './types.ts';
-export declare const stateDir: () => string;
-export declare function carryLegacyState(): void;
-export declare function allowFileFor(connectorId: string): string;
-export interface AllowState {
-    ids: Record<string, number>;
-}
-export declare function emptyAllowed(): AllowState;
-export declare function loadAllowed(file: string): AllowState;
-export declare function saveAllowed(file: string, state: AllowState): void;
-export declare function isAllowed(state: AllowState, id: string | number | null | undefined): boolean;
-export declare function addAllowed(state: AllowState, id: string | number, now: number): AllowState;
-export declare function isSenderAllowed(connectorId: string, senderId: string, deps?: {
-    policy?: GatePolicy;
-}): Promise<boolean>;
-export declare function makeThrottle(maxAttempts?: number, windowMs?: number): (id: string | number, now?: number) => boolean;
+export declare function makeThrottle(maxNotices?: number, windowMs?: number): (id: string | number, now?: number) => boolean;

package/dist/orchestrator/allow.js

@@ -1,63 +1,13 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { loadGatePolicy } from "./config.js";
-import { carryInto, dataDir } from "../data-dir.js";
-export const stateDir = () => process.env['ORCHESTRATOR_STATE_DIR'] ?? path.join(dataDir(), 'state');
-function legacyStateDirs() {
-    return [
-        path.join(process.cwd(), 'packages', 'plugin-orchestrator', 'runtime', 'state'),
-        path.join(process.cwd(), 'node_modules', '@coffer-org', 'plugin-orchestrator', 'runtime', 'state'),
-    ];
-}
-export function carryLegacyState() {
-    carryInto(stateDir(), ...legacyStateDirs());
-}
-export function allowFileFor(connectorId) {
-    return path.join(stateDir(), `${connectorId}.allowed.json`);
-}
-export function emptyAllowed() {
-    return { ids: {} };
-}
-export function loadAllowed(file) {
-    try {
-        const obj = JSON.parse(fs.readFileSync(file, 'utf-8'));
-        if (obj && typeof obj === 'object' && 'ids' in obj && typeof obj.ids === 'object') {
-            return obj;
-        }
-        return emptyAllowed();
-    }
-    catch {
-        return emptyAllowed();
-    }
-}
-export function saveAllowed(file, state) {
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    const tmp = `${file}.${process.pid}.tmp`;
-    fs.writeFileSync(tmp, JSON.stringify(state), 'utf-8');
-    fs.renameSync(tmp, file);
-}
-export function isAllowed(state, id) {
-    return id != null && Object.prototype.hasOwnProperty.call(state.ids, String(id));
-}
-export function addAllowed(state, id, now) {
-    return { ids: { ...state.ids, [String(id)]: now } };
-}
-export async function isSenderAllowed(connectorId, senderId, deps) {
-    const policy = deps?.policy ?? (await loadGatePolicy());
-    if (!policy.accessPassword)
-        return true;
-    return isAllowed(loadAllowed(allowFileFor(connectorId)), senderId);
-}
-export function makeThrottle(maxAttempts = 5, windowMs = 60_000) {
+export function makeThrottle(maxNotices = 5, windowMs = 60_000) {
     const hits = new Map();
-    return function allowAttempt(id, now = Date.now()) {
+    return function allowNotice(id, now = Date.now()) {
         const key = String(id);
         const rec = hits.get(key);
         if (!rec || now - rec.start >= windowMs) {
             hits.set(key, { start: now, count: 1 });
             return true;
         }
-        if (rec.count >= maxAttempts)
+        if (rec.count >= maxNotices)
             return false;
         rec.count += 1;
         return true;

package/dist/orchestrator/config.js

@@ -3,7 +3,6 @@ export function buildPolicy(dbSettings = {}) {
     const db = dbSettings;
     return {
         ...(typeof db.agent_id === 'string' && db.agent_id ? { agentId: db.agent_id } : {}),
-        accessPassword: db.access_password ?? '',
         triggerPrefix: db.trigger_prefix ?? '',
         replyWindow: Number(db.reply_window ?? 1800) || 1800,
     };

package/dist/orchestrator/context-facts.d.ts

@@ -0,0 +1,27 @@
+import type { AuthRole } from '../plugin-hooks.ts';
+export interface ContextFact {
+    name: string;
+    value: string;
+    attrs?: Record<string, string>;
+}
+export declare const CONNECTOR_FACT_NAME: RegExp;
+export declare const CONTEXT_GAP_MS: number;
+export declare const MAX_SPEAKER_NAME = 80;
+export declare const MAX_FACT_VALUE = 200;
+export declare const MAX_CONNECTOR_FACTS = 12;
+export declare function oneLine(value: string, maxLen?: number): string;
+export interface ContextSpeaker {
+    id: string;
+    name: string;
+    role: AuthRole;
+}
+export interface ContextInput {
+    connectorFacts: readonly ContextFact[];
+    speaker: ContextSpeaker;
+    now: Date;
+    timeZone: string;
+    previous: readonly ContextFact[] | null;
+    previousAt: Date | null;
+}
+export declare function humanizeGap(ms: number): string;
+export declare function buildContextFacts(input: ContextInput): ContextFact[];