@coffer-org/server 7.1.0 → 7.3.0

package/dist/auth-api.d.ts

@@ -7,6 +7,10 @@ declare module 'fastify' {
 }
 export declare const PUBLIC_API_PATHS: string[];
 export declare function startPasswordSession(reply: FastifyReply, login: string, password: string): Promise<AuthUser | null>;
+export declare function parseBasicCredential(header: string | undefined): {
+    login: string;
+    secret: string;
+} | null;
 export declare function resolveRequestUser(req: FastifyRequest): Promise<AuthUser | null>;
 export declare function requireAdmin(req: FastifyRequest, reply: FastifyReply): boolean;
 export declare function registerAuthApi(app: FastifyInstance): Promise<void>;

package/dist/auth-api.js

@@ -2,6 +2,8 @@ import { field } from '@coffer-org/sdk/fields';
 import { materializeTree } from '@coffer-org/sdk/materialize/pipeline';
 import { countUsers, createUser, findUserByLogin, findUserById, getPasswordHash, listUsers, updateUser, deleteUser, countAdmins, createSession, resolveSession, deleteSession, createApiToken, resolveApiToken, listApiTokens, revokeApiToken, } from "./auth-store.js";
 import { resolveAccessToken } from "./oauth-store.js";
+import { listLinks, unlink, mintLinkCode } from "./identity-link.js";
+import { listLinkableConnectors, connectorLinkUrl } from "./orchestrator/index.js";
 import { mcpResource } from "./public-url.js";
 import { verifyPassword } from "./auth-crypto.js";
 import { maskSecrets, preserveSecrets } from "./field-masking.js";
@@ -11,6 +13,7 @@ import { USERS_SHELF } from '@coffer-org/sdk/users-shelf';
 const PASSWORD_FIELDS = materializeTree({ password: field.password({}) });
 const SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 const COOKIE_NAME = 'sid';
+const LINK_CODE_TTL_MS = 10 * 60 * 1000;
 export const PUBLIC_API_PATHS = ['/api/auth/status', '/api/auth/login', '/api/auth/setup'];
 function readCookie(req, name) {
     const header = req.headers.cookie;
@@ -37,12 +40,32 @@ export async function startPasswordSession(reply, login, password) {
     setCookie(reply, raw, SESSION_TTL_MS / 1000);
     return row;
 }
+export function parseBasicCredential(header) {
+    if (!header?.startsWith('Basic '))
+        return null;
+    let decoded;
+    try {
+        decoded = Buffer.from(header.slice('Basic '.length).trim(), 'base64').toString('utf8');
+    }
+    catch {
+        return null;
+    }
+    const at = decoded.indexOf(':');
+    if (at <= 0)
+        return null;
+    return { login: decoded.slice(0, at), secret: decoded.slice(at + 1) };
+}
 export async function resolveRequestUser(req) {
     const auth = req.headers.authorization;
     if (auth?.startsWith('Bearer ')) {
         const raw = auth.slice('Bearer '.length);
         return (await resolveApiToken(raw)) ?? (await resolveAccessToken(raw, await mcpResource(req)));
     }
+    const basic = parseBasicCredential(auth);
+    if (basic) {
+        const user = await resolveApiToken(basic.secret);
+        return user && user.login === basic.login ? user : null;
+    }
     const sid = readCookie(req, COOKIE_NAME);
     if (!sid)
         return null;
@@ -208,4 +231,34 @@ export async function registerAuthApi(app) {
             return reply.code(404).send({ error: 'not_found' });
         return { ok: true };
     });
+    app.get('/api/auth/links', async (req, reply) => {
+        if (!req.user)
+            return reply.code(401).send({ error: 'unauthorized' });
+        return { links: await listLinks(req.user.id), linkable: listLinkableConnectors() };
+    });
+    app.post('/api/auth/links', async (req, reply) => {
+        if (!req.user)
+            return reply.code(401).send({ error: 'unauthorized' });
+        const minted = await mintLinkCode(req.user.id, LINK_CODE_TTL_MS);
+        const links = {};
+        for (const connectorId of listLinkableConnectors()) {
+            const url = connectorLinkUrl(connectorId, minted.raw);
+            if (url)
+                links[connectorId] = url;
+        }
+        return { ...minted, links };
+    });
+    app.delete('/api/auth/links/:connector/:externalId', async (req, reply) => {
+        if (!req.user)
+            return reply.code(401).send({ error: 'unauthorized' });
+        const { connector, externalId } = req.params;
+        const own = await listLinks(req.user.id);
+        const owns = own.some((l) => l.connector === connector && l.externalId === externalId);
+        if (!owns)
+            return reply.code(404).send({ error: 'not_found' });
+        const ok = await unlink(connector, externalId);
+        if (!ok)
+            return reply.code(404).send({ error: 'not_found' });
+        return { ok: true };
+    });
 }

package/dist/auth-store.d.ts

@@ -1,3 +1,5 @@
+import { generateToken, hashToken } from './auth-crypto.ts';
+export { generateToken, hashToken };
 export interface AuthUser {
     id: number;
     login: string;

package/dist/auth-store.js

@@ -1,5 +1,6 @@
 import { getEm } from "./db.js";
 import { hashPassword, generateToken, hashToken } from "./auth-crypto.js";
+export { generateToken, hashToken };
 function toAuthUser(row) {
     return {
         id: row.id,

package/dist/background-scheduler.d.ts

@@ -17,6 +17,7 @@ export interface BackgroundScheduler {
     start(): void;
     stop(): void;
 }
+export declare const DEFAULT_TASK_TIMEOUT_MS = 600000;
 export declare function makeScheduler(opts?: SchedulerOpts): BackgroundScheduler;
 export declare function startScheduler(tasks: BackgroundTask[], opts?: SchedulerOpts): void;
 export declare function stopScheduler(): void;

package/dist/background-scheduler.js

@@ -6,10 +6,11 @@ const defaultSetTimer = (cb, ms) => {
         t.unref();
     return t;
 };
+export const DEFAULT_TASK_TIMEOUT_MS = 600_000;
 export function makeScheduler(opts = {}) {
     const startupDelayMs = opts.startupDelayMs ?? (Number(process.env['BG_STARTUP_DELAY_MS']) || 600_000);
     const gapMs = opts.gapMs ?? (Number(process.env['BG_GAP_MS']) || 30_000);
-    const defaultTimeoutMs = opts.taskTimeoutMs ?? (Number(process.env['BG_TASK_TIMEOUT_MS']) || 600_000);
+    const defaultTimeoutMs = opts.taskTimeoutMs ?? (Number(process.env['BG_TASK_TIMEOUT_MS']) || DEFAULT_TASK_TIMEOUT_MS);
     const setTimer = opts.setTimer ?? defaultSetTimer;
     const clearTimer = opts.clearTimer ?? ((h) => clearTimeout(h));
     const tasks = [];

package/dist/entity-schema.d.ts

@@ -25,6 +25,8 @@ export declare const MsgLogSchema: EntitySchema<any, never, import("@mikro-orm/c
 export declare const UserSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const SessionSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const ApiTokenSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
+export declare const IdentityLinkSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
+export declare const LinkCodeSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const OAuthClientSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const OAuthCodeSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const OAuthTokenSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;

package/dist/entity-schema.js

@@ -209,6 +209,9 @@ export const ThreadStateSchema = new EntitySchema({
         chat_id: { type: 'text', primary: true },
         agent_id: { type: 'text', nullable: true },
         preset_id: { type: 'text', nullable: true },
+        title: { type: 'text', nullable: true },
+        owner: { type: 'text', nullable: true },
+        visibility: { type: 'text', nullable: true },
         updated_at: { type: 'text' },
     },
 });
@@ -274,6 +277,27 @@ export const ApiTokenSchema = new EntitySchema({
         revoked: { type: 'integer' },
     },
 });
+export const IdentityLinkSchema = new EntitySchema({
+    name: '_IdentityLink',
+    tableName: '_identity_links',
+    properties: {
+        id: { type: 'integer', primary: true, autoincrement: true },
+        connector: { type: 'text' },
+        external_id: { type: 'text' },
+        user_id: { type: 'integer' },
+        linked_at: { type: 'text' },
+    },
+});
+export const LinkCodeSchema = new EntitySchema({
+    name: '_LinkCode',
+    tableName: '_link_codes',
+    properties: {
+        code_hash: { type: 'text', primary: true },
+        user_id: { type: 'integer' },
+        expires_at: { type: 'text' },
+        created_at: { type: 'text' },
+    },
+});
 export const OAuthClientSchema = new EntitySchema({
     name: '_OAuthClient',
     tableName: '_oauth_clients',
@@ -331,5 +355,7 @@ export const systemEntities = [
     OAuthTokenSchema,
     ThreadMessageSchema,
     ThreadStateSchema,
+    IdentityLinkSchema,
+    LinkCodeSchema,
     buildSettingsEntitySchema(SYSTEM_SETTINGS_ID, SYSTEM_SETTINGS),
 ];

package/dist/identity-link.d.ts

@@ -0,0 +1,15 @@
+export interface IdentityLink {
+    connector: string;
+    externalId: string;
+    userId: number;
+    linkedAt: string;
+}
+export declare function findLinkedUser(connector: string, externalId: string): Promise<number | null>;
+export declare function listLinks(userId: number): Promise<IdentityLink[]>;
+export declare function unlink(connector: string, externalId: string): Promise<boolean>;
+export declare function mintLinkCode(userId: number, ttlMs: number): Promise<{
+    raw: string;
+    expiresAt: string;
+}>;
+export declare function redeemLinkCode(raw: string, connector: string, externalId: string): Promise<number | null>;
+export declare function pruneLinkCodes(): Promise<void>;

package/dist/identity-link.js

@@ -0,0 +1,76 @@
+import { getEm } from "./db.js";
+import { generateToken, hashToken, findUserById } from "./auth-store.js";
+export async function findLinkedUser(connector, externalId) {
+    const em = getEm().fork();
+    const row = (await em.findOne('_IdentityLink', {
+        connector,
+        external_id: externalId,
+    }));
+    if (!row)
+        return null;
+    const user = await findUserById(row.user_id);
+    return user && !user.disabled ? row.user_id : null;
+}
+export async function listLinks(userId) {
+    const em = getEm().fork();
+    const rows = (await em.find('_IdentityLink', { user_id: userId }));
+    return rows.map((r) => ({
+        connector: r.connector,
+        externalId: r.external_id,
+        userId: r.user_id,
+        linkedAt: r.linked_at,
+    }));
+}
+export async function unlink(connector, externalId) {
+    const em = getEm().fork();
+    const deleted = await em.nativeDelete('_IdentityLink', { connector, external_id: externalId });
+    return deleted > 0;
+}
+export async function mintLinkCode(userId, ttlMs) {
+    const em = getEm().fork();
+    const raw = generateToken();
+    const expiresAt = new Date(Date.now() + ttlMs).toISOString();
+    em.create('_LinkCode', {
+        code_hash: hashToken(raw),
+        user_id: userId,
+        expires_at: expiresAt,
+        created_at: new Date().toISOString(),
+    });
+    await em.flush();
+    return { raw, expiresAt };
+}
+async function setLink(em, connector, externalId, userId) {
+    const existing = (await em.findOne('_IdentityLink', {
+        connector,
+        external_id: externalId,
+    }));
+    const linkedAt = new Date().toISOString();
+    if (existing) {
+        em.assign(existing, { user_id: userId, linked_at: linkedAt });
+    }
+    else {
+        em.create('_IdentityLink', { connector, external_id: externalId, user_id: userId, linked_at: linkedAt });
+    }
+    await em.flush();
+}
+export async function redeemLinkCode(raw, connector, externalId) {
+    const em = getEm().fork();
+    const hash = hashToken(raw);
+    const row = (await em.findOne('_LinkCode', { code_hash: hash }));
+    if (!row)
+        return null;
+    const deleted = await em.nativeDelete('_LinkCode', { code_hash: hash });
+    if (deleted === 0)
+        return null;
+    if (row.expires_at < new Date().toISOString())
+        return null;
+    const owner = await findUserById(row.user_id);
+    if (!owner || owner.disabled)
+        return null;
+    await setLink(em, connector, externalId, row.user_id);
+    return row.user_id;
+}
+export async function pruneLinkCodes() {
+    const em = getEm().fork();
+    await em.nativeDelete('_LinkCode', { expires_at: { $lt: new Date().toISOString() } });
+}

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

@@ -1,4 +1,30 @@
 import type { LocaleResolver } from '../locale-registry.ts';
+import { type AgentMeta } from '@coffer-org/sdk/library';
+import type { Condition } from '@coffer-org/sdk/condition';
+interface ShelfClient {
+    shelf: string;
+    library: string;
+    label: string;
+    agent?: string;
+    standalone?: boolean;
+    fields: unknown[];
+}
+interface ExtendClient {
+    id: string;
+    attachTo: {
+        library: string;
+        shelf?: string;
+    }[];
+    showWhen?: Condition;
+    agent?: AgentMeta | string;
+}
+interface LibraryClient {
+    id: string;
+    label: string;
+    agent?: AgentMeta | string;
+    extends?: ExtendClient[];
+    shelves: ShelfClient[];
+}
 export interface ShelfIndexEntry {
     library: string;
     libraryLabel: string;
@@ -25,13 +51,20 @@ export declare const FILE_WRITE_HINT: string;
 export declare const SOURCE_WRITE_HINT: string;
 export declare const DERIVED_WRITE_HINT: string;
 export declare const serverOwnedPartsHint: (roles: string[]) => string;
+export interface OperatingRule {
+    source: string;
+    when?: string;
+    text: string;
+}
 export interface ShelfDescription {
     library: string;
     shelf: string;
     label: string;
     agent?: string;
+    operatingRules?: OperatingRule[];
     fields: FieldInfo[];
 }
+export declare function collectOperatingRules(lib: LibraryClient, shelf: string): OperatingRule[];
 interface SchemaClient {
     getSchema(): Promise<unknown>;
 }
@@ -46,6 +79,6 @@ export declare class SchemaCache {
     private load;
     index(): Promise<ShelfIndexEntry[]>;
     describeShelf(library: string, shelf: string): Promise<ShelfDescription>;
-    private find;
+    private locate;
 }
 export {};

package/dist/mcp-contract/schema.js

@@ -1,3 +1,6 @@
+import { normalizeAgentMeta } from '@coffer-org/sdk/library';
+import { extendMatches } from '@coffer-org/sdk/extend';
+import { describeCondition } from '@coffer-org/sdk/condition';
 export const FILE_WRITE_HINT = 'Uploaded file only: {"name":"<filename returned by POST /api/upload>"} ' +
     '(or an array of those when the field is multiple). ' +
     'A remote URL is rejected — the server stores files, not links. ' +
@@ -13,6 +16,22 @@ export const DERIVED_WRITE_HINT = 'Read-only — the server recomputes this fiel
 export const serverOwnedPartsHint = (roles) => `Partly read-only — the server owns ${roles.map((r) => `\`${r}\``).join(', ')} in this value and ` +
     `computes ${roles.length > 1 ? 'them' : 'it'} on every write. Send the other roles only; anything ` +
     `sent for these is discarded, and a read returns the server's value.`;
+export function collectOperatingRules(lib, shelf) {
+    const out = [];
+    const libAgent = normalizeAgentMeta(lib.agent);
+    if (libAgent?.instructions)
+        out.push({ source: lib.id, text: libAgent.instructions });
+    for (const e of lib.extends ?? []) {
+        if (!extendMatches(e, lib.id, shelf))
+            continue;
+        const meta = normalizeAgentMeta(e.agent);
+        if (!meta?.instructions)
+            continue;
+        const when = describeCondition(e.showWhen, (f) => f).join(' and ');
+        out.push({ source: e.id, ...(when ? { when } : {}), text: meta.instructions });
+    }
+    return out;
+}
 function serverOwnedRoles(t) {
     const parts = t.parts ?? [];
     return parts.filter((p) => p.mode === 'computedStored').map((p) => p.role);
@@ -89,20 +108,24 @@ export class SchemaCache {
         })));
     }
     async describeShelf(library, shelf) {
-        let m = this.find(await this.load(), library, shelf);
-        if (!m)
-            m = this.find(await this.load(true), library, shelf);
-        if (!m)
+        let at = this.locate(await this.load(), library, shelf);
+        if (!at)
+            at = this.locate(await this.load(true), library, shelf);
+        if (!at)
             throw new Error(`unknown_shelf ${library}/${shelf}`);
+        const rules = collectOperatingRules(at.lib, shelf);
         return {
             library,
             shelf,
-            label: this.display(m.label, m.shelf),
-            ...(m.agent ? { agent: m.agent } : {}),
-            fields: flattenFields(m.fields),
+            label: this.display(at.m.label, at.m.shelf),
+            ...(at.m.agent ? { agent: at.m.agent } : {}),
+            ...(rules.length ? { operatingRules: rules } : {}),
+            fields: flattenFields(at.m.fields),
         };
     }
-    find(libraries, library, shelf) {
-        return libraries.find((v) => v.id === library)?.shelves.find((m) => m.shelf === shelf);
+    locate(libraries, library, shelf) {
+        const lib = libraries.find((v) => v.id === library);
+        const m = lib?.shelves.find((s) => s.shelf === shelf);
+        return lib && m ? { lib, m } : undefined;
     }
 }

package/dist/mcp-contract/tools.js

@@ -53,7 +53,9 @@ export function buildTools(client, cache, locales) {
         },
         {
             name: 'describe_shelf',
-            description: 'Detailed shelf schema: the shelf note (agent), then fields with kind/prim/required, relation/options, and ' +
+            description: 'Detailed shelf schema: the shelf note (agent), the operating rules that govern writing here ' +
+                '(operatingRules — from the library and from any extra field-set attached to this shelf, each ' +
+                'with the condition it applies under), then fields with kind/prim/required, relation/options, and ' +
                 'a per-field note (agent) saying what that field means. A collection is one entry with multiple:true and its ' +
                 'row shape in fields[]. A field with derived:true is computed by the server and rejects writes — omit it when ' +
                 'writing. Call BEFORE create_record/update_record.',

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

@@ -4,7 +4,9 @@ import { type ToolResult } from './mcp-contract/tools.ts';
 import { type LocaleResolver } from './locale-registry.ts';
 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;
@@ -20,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<{
@@ -58,12 +60,12 @@ export declare function collectLibraryPurposes(reg?: {
         meta: {
             id: string;
             label?: string;
-            agent?: string;
+            agent?: AgentMeta | string;
         };
     }[];
     extends_: {
         id: string;
-        agent?: string;
+        agent?: AgentMeta | string;
         showWhen?: Condition;
         attachTo: {
             library: string;
@@ -72,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;