@coffer-org/server 2.4.0 → 2.5.1

package/dist/entity-schema.d.ts

@@ -16,6 +16,7 @@ export declare const MigrationRowSchema: EntitySchema<any, never, import("@mikro
 export declare const SeedRowSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const EmbeddingSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const PluginStateSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
+export declare const RecordActivitySchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const ThreadMessageSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare function buildPluginEntities(plugins: PluginManifest[]): EntitySchema[];
 export declare const MsgLogSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;

package/dist/entity-schema.js

@@ -152,6 +152,19 @@ export const PluginStateSchema = new EntitySchema({
         value: { type: 'text' },
     },
 });
+export const RecordActivitySchema = new EntitySchema({
+    name: '_RecordActivity',
+    tableName: '_record_activity',
+    properties: {
+        user_id: { type: 'integer', primary: true },
+        library: { type: 'text', primary: true },
+        shelf: { type: 'text', primary: true },
+        record_id: { type: 'integer', primary: true },
+        favorite: { type: 'integer' },
+        view_count: { type: 'integer' },
+        last_viewed_at: { type: 'text', nullable: true },
+    },
+});
 export const ThreadMessageSchema = new EntitySchema({
     name: '_ThreadMessage',
     tableName: '_thread_message',
@@ -268,7 +281,7 @@ export const OAuthTokenSchema = new EntitySchema({
 });
 export const systemEntities = [
     EventSchema, PluginRowSchema, MigrationRowSchema, SeedRowSchema,
-    EmbeddingSchema, PluginStateSchema, MsgLogSchema,
+    EmbeddingSchema, PluginStateSchema, RecordActivitySchema, MsgLogSchema,
     UserSchema, SessionSchema, ApiTokenSchema,
     OAuthClientSchema, OAuthCodeSchema, OAuthTokenSchema,
     ThreadMessageSchema,

package/dist/index.js

@@ -24,7 +24,7 @@ import { baseUrl } from "./public-url.js";
 import { discoverPluginAssets, discoverRuntime } from "./plugin-discovery.js";
 import { checkLatestVersion, resolveUpdateTarget, resolveAllUpdateTargets, resolveBaseTargets, resolveRuntimeTarget, runNpmInstall, } from "./plugin-updates.js";
 import { buildClientSchema } from "./schema-api.js";
-import { recordList, recordListPage, isPagedRequest, recordGet, recordCreate, recordUpdate, recordDelete, recordRestore, recordPurge, recordTrashList, UnknownShelfError, } from "./records-api.js";
+import { recordList, recordListPage, isPagedRequest, recordGet, recordCreate, recordUpdate, recordDelete, recordRestore, recordPurge, recordTrashList, MAX_PAGE, UnknownShelfError, } from "./records-api.js";
 import { maskTree, preserveTree } from "./field-masking.js";
 import { writePluginSettings } from "./settings-write.js";
 import { rootLogger, getLogger } from "./log.js";
@@ -34,6 +34,8 @@ import { verifyUploadTicket } from "./upload-ticket.js";
 import { setPluginState } from "./plugin-state.js";
 import { SEARCH_STATE_PLUGIN, SEARCH_CURSOR_KEY } from "./search-indexer.js";
 import { globalSearch } from "./global-search.js";
+import { applySmartRanking, getRecordActivity, markRecordViewed, setRecordFavorite } from "./record-activity.js";
+import { tracksRecordActivity } from "./record-activity-policy.js";
 const ENV_FILE = join(process.cwd(), '.env');
 if (existsSync(ENV_FILE))
     process.loadEnvFile(ENV_FILE);
@@ -410,14 +412,25 @@ app.get('/api/:library/:shelf', async (req, reply) => {
     };
     try {
         if (!paged) {
-            const rows = await recordList(library, shelf, query, opts);
+            let rows = await recordList(library, shelf, query, opts);
+            if (req.user && tracksRecordActivity(req.headers))
+                rows = await applySmartRanking(req.user.id, library, shelf, rows);
             return rows.map((r) => maskRecordRow(library, shelf, r));
         }
-        const page = await recordListPage(library, shelf, query, {
+        const pageOpts = {
             ...opts,
             limit: limit === undefined ? undefined : Number(limit),
             offset: offset === undefined ? undefined : Number(offset),
-        });
+        };
+        let page = await recordListPage(library, shelf, query, pageOpts);
+        if (req.user && tracksRecordActivity(req.headers)) {
+            const allRows = await recordList(library, shelf, query, { ...opts, limit: undefined, offset: undefined });
+            const ranked = await applySmartRanking(req.user.id, library, shelf, allRows);
+            const rawLimit = Number.isFinite(pageOpts.limit) ? Math.trunc(pageOpts.limit) : MAX_PAGE;
+            const pageLimit = Math.min(Math.max(1, rawLimit), MAX_PAGE);
+            const pageOffset = Math.max(0, Number.isFinite(pageOpts.offset) ? Math.trunc(pageOpts.offset) : 0);
+            page = { rows: ranked.slice(pageOffset, pageOffset + pageLimit), total: ranked.length };
+        }
         return { rows: page.rows.map((r) => maskRecordRow(library, shelf, r)), total: page.total };
     }
     catch (e) {
@@ -426,6 +439,43 @@ app.get('/api/:library/:shelf', async (req, reply) => {
         throw e;
     }
 });
+app.get('/api/:library/:shelf/:id/activity', async (req, reply) => {
+    const { library, shelf, id } = req.params;
+    const rid = Number(id);
+    if (isNaN(rid))
+        return reply.code(400).send({ error: 'invalid_id' });
+    try {
+        const row = await recordGet(library, shelf, rid);
+        if (!row)
+            return reply.code(404).send({ error: 'not_found' });
+        return { activity: await getRecordActivity(req.user.id, library, shelf, rid) };
+    }
+    catch (e) {
+        if (e instanceof UnknownShelfError)
+            return reply.code(404).send({ error: 'unknown_shelf' });
+        throw e;
+    }
+});
+app.patch('/api/:library/:shelf/:id/activity', async (req, reply) => {
+    const { library, shelf, id } = req.params;
+    const rid = Number(id);
+    if (isNaN(rid))
+        return reply.code(400).send({ error: 'invalid_id' });
+    const body = (req.body ?? {});
+    if (typeof body.favorite !== 'boolean')
+        return reply.code(400).send({ error: 'favorite_must_be_boolean' });
+    try {
+        const row = await recordGet(library, shelf, rid);
+        if (!row)
+            return reply.code(404).send({ error: 'not_found' });
+        return { activity: await setRecordFavorite(req.user.id, library, shelf, rid, body.favorite) };
+    }
+    catch (e) {
+        if (e instanceof UnknownShelfError)
+            return reply.code(404).send({ error: 'unknown_shelf' });
+        throw e;
+    }
+});
 app.get('/api/:library/:shelf/:id', async (req, reply) => {
     const { library, shelf, id } = req.params;
     const rid = Number(id);
@@ -435,7 +485,11 @@ app.get('/api/:library/:shelf/:id', async (req, reply) => {
         const row = await recordGet(library, shelf, rid);
         if (!row)
             return reply.code(404).send({ error: 'not_found' });
-        return maskRecordRow(library, shelf, row);
+        const masked = maskRecordRow(library, shelf, row);
+        if (req.user && tracksRecordActivity(req.headers)) {
+            return { ...masked, _activity: await markRecordViewed(req.user.id, library, shelf, rid) };
+        }
+        return masked;
     }
     catch (e) {
         if (e instanceof UnknownShelfError)

package/dist/msg-log.d.ts

@@ -8,4 +8,14 @@ export interface MsgLogRow {
     tokensOut: number | null;
     ms: number | null;
 }
+export interface MsgLogDiagnosticRow {
+    id: number;
+    ts: string;
+    connector: string;
+    role: 'user' | 'assistant';
+    tokensIn: number | null;
+    tokensOut: number | null;
+    ms: number | null;
+}
 export declare function logMessage(row: MsgLogRow): Promise<void>;
+export declare function listRecentMessageMetrics(limit?: number): Promise<MsgLogDiagnosticRow[]>;

package/dist/msg-log.js

@@ -3,3 +3,19 @@ export async function logMessage(row) {
     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]);
 }
+export async function listRecentMessageMetrics(limit = 25) {
+    const bounded = Math.max(1, Math.min(100, Math.trunc(limit)));
+    const rows = (await getEm().fork().getConnection().execute(`SELECT id, ts, connector, role, tokens_in, tokens_out, ms
+       FROM _orch_msg_log
+      ORDER BY id DESC
+      LIMIT ?`, [bounded]));
+    return rows.map((r) => ({
+        id: Number(r['id']),
+        ts: String(r['ts']),
+        connector: String(r['connector']),
+        role: r['role'] === 'assistant' ? 'assistant' : 'user',
+        tokensIn: r['tokens_in'] == null ? null : Number(r['tokens_in']),
+        tokensOut: r['tokens_out'] == null ? null : Number(r['tokens_out']),
+        ms: r['ms'] == null ? null : Number(r['ms']),
+    }));
+}

package/dist/record-activity-policy.d.ts

@@ -0,0 +1,3 @@
+export declare const AUTOMATED_ACTIVITY_HEADER = "x-coffer-automated";
+export type RequestHeaders = Record<string, string | string[] | undefined>;
+export declare function tracksRecordActivity(headers: RequestHeaders): boolean;

package/dist/record-activity-policy.js

@@ -0,0 +1,7 @@
+export const AUTOMATED_ACTIVITY_HEADER = 'x-coffer-automated';
+export function tracksRecordActivity(headers) {
+    const entry = Object.entries(headers).find(([key]) => key.toLowerCase() === AUTOMATED_ACTIVITY_HEADER);
+    const marker = entry?.[1];
+    const value = Array.isArray(marker) ? marker[0] : marker;
+    return value?.toLowerCase().trim() !== 'true';
+}

package/dist/record-activity.d.ts

@@ -0,0 +1,11 @@
+export interface RecordActivityClient {
+    favorite: boolean;
+    viewCount: number;
+    lastViewedAt: string | null;
+    score: number;
+}
+export declare function getRecordActivity(userId: number, library: string, shelf: string, recordId: number): Promise<RecordActivityClient>;
+export declare function markRecordViewed(userId: number, library: string, shelf: string, recordId: number, now?: string): Promise<RecordActivityClient>;
+export declare function setRecordFavorite(userId: number, library: string, shelf: string, recordId: number, favorite: boolean): Promise<RecordActivityClient>;
+export declare function deleteRecordActivity(library: string, shelf: string, recordId: number): Promise<void>;
+export declare function applySmartRanking(userId: number, library: string, shelf: string, rows: Record<string, unknown>[], now?: Date): Promise<Record<string, unknown>[]>;

package/dist/record-activity.js

@@ -0,0 +1,118 @@
+import { getEm } from "./db.js";
+import { shelfTableName } from "./entity-schema.js";
+const DAY_MS = 24 * 60 * 60 * 1000;
+const CREATED_HALF_LIFE_DAYS = 30;
+const EDITED_HALF_LIFE_DAYS = 14;
+function activityKey(userId, library, shelf, recordId) {
+    return { user_id: userId, library, shelf, record_id: recordId };
+}
+function toClient(row) {
+    return {
+        favorite: row?.favorite === 1,
+        viewCount: Number(row?.view_count ?? 0),
+        lastViewedAt: row?.last_viewed_at ?? null,
+        score: 0,
+    };
+}
+async function getActivityRow(userId, library, shelf, recordId) {
+    const em = getEm().fork();
+    return (await em.findOne('_RecordActivity', activityKey(userId, library, shelf, recordId)));
+}
+export async function getRecordActivity(userId, library, shelf, recordId) {
+    return toClient((await getActivityRow(userId, library, shelf, recordId)) ?? undefined);
+}
+export async function markRecordViewed(userId, library, shelf, recordId, now = new Date().toISOString()) {
+    const em = getEm().fork();
+    const key = activityKey(userId, library, shelf, recordId);
+    const row = (await em.findOne('_RecordActivity', key));
+    if (row) {
+        row.view_count = Number(row.view_count ?? 0) + 1;
+        row.last_viewed_at = now;
+        await em.flush();
+        return toClient(row);
+    }
+    const created = em.create('_RecordActivity', {
+        ...key,
+        favorite: 0,
+        view_count: 1,
+        last_viewed_at: now,
+    });
+    await em.flush();
+    return toClient(created);
+}
+export async function setRecordFavorite(userId, library, shelf, recordId, favorite) {
+    const em = getEm().fork();
+    const key = activityKey(userId, library, shelf, recordId);
+    const row = (await em.findOne('_RecordActivity', key));
+    if (row) {
+        row.favorite = favorite ? 1 : 0;
+        await em.flush();
+        return toClient(row);
+    }
+    const created = em.create('_RecordActivity', {
+        ...key,
+        favorite: favorite ? 1 : 0,
+        view_count: 0,
+        last_viewed_at: null,
+    });
+    await em.flush();
+    return toClient(created);
+}
+export async function deleteRecordActivity(library, shelf, recordId) {
+    const em = getEm().fork();
+    await em.nativeDelete('_RecordActivity', { library, shelf, record_id: recordId });
+}
+async function listActivityRows(userId, library, shelf, ids) {
+    if (ids.length === 0)
+        return new Map();
+    const em = getEm().fork();
+    const rows = (await em.find('_RecordActivity', { user_id: userId, library, shelf, record_id: { $in: ids } }));
+    return new Map(rows.map((row) => [Number(row.record_id), row]));
+}
+function decayBonus(base, timestamp, halfLifeDays, nowMs) {
+    const then = timestamp ? Date.parse(timestamp) : NaN;
+    if (!Number.isFinite(then))
+        return 0;
+    const ageDays = Math.max(0, nowMs - then) / DAY_MS;
+    return base * 2 ** (-ageDays / halfLifeDays);
+}
+export async function applySmartRanking(userId, library, shelf, rows, now = new Date()) {
+    if (rows.length === 0)
+        return rows;
+    const ids = rows.map((row) => Number(row.id)).filter((id) => Number.isInteger(id));
+    const activities = await listActivityRows(userId, library, shelf, ids);
+    const em = getEm().fork();
+    const timestamps = (await em.find(shelfTableName(library, shelf), { id: { $in: ids }, deleted_at: null }, { fields: ['id', 'created_at', 'updated_at'] }));
+    const dates = new Map(timestamps.map((row) => [Number(row.id), row]));
+    const viewed = rows
+        .map((row) => ({ id: Number(row.id), last: activities.get(Number(row.id))?.last_viewed_at }))
+        .filter((row) => typeof row.last === 'string' && Number.isFinite(Date.parse(row.last)))
+        .sort((a, b) => Date.parse(b.last) - Date.parse(a.last));
+    const recentReadIds = new Set(viewed.slice(0, Math.max(1, Math.ceil(rows.length * 0.1))).map((row) => row.id));
+    const nowMs = now.getTime();
+    const decorated = rows.map((row) => {
+        const id = Number(row.id);
+        const activity = activities.get(id);
+        const date = dates.get(id);
+        const created = date?.created_at;
+        const updated = date?.updated_at;
+        const createdBonus = decayBonus(75, created, CREATED_HALF_LIFE_DAYS, nowMs);
+        const edited = created && updated && Date.parse(updated) > Date.parse(created) ? updated : null;
+        const editedBonus = decayBonus(50, edited, EDITED_HALF_LIFE_DAYS, nowMs);
+        const score = (activity?.favorite === 1 ? 100 : 0) + createdBonus + editedBonus + (recentReadIds.has(id) ? 30 : 0);
+        const client = {
+            favorite: activity?.favorite === 1,
+            viewCount: Number(activity?.view_count ?? 0),
+            lastViewedAt: activity?.last_viewed_at ?? null,
+            score,
+        };
+        return { row: { ...row, _activity: client }, client, updated: updated ?? '' };
+    });
+    return decorated
+        .sort((a, b) => b.client.score - a.client.score ||
+        b.client.viewCount - a.client.viewCount ||
+        String(b.client.lastViewedAt ?? '').localeCompare(String(a.client.lastViewedAt ?? '')) ||
+        b.updated.localeCompare(a.updated) ||
+        Number(b.row.id) - Number(a.row.id))
+        .map((item) => item.row);
+}

package/dist/records-api.js

@@ -8,6 +8,7 @@ import { getEm } from "./db.js";
 import { decodeTemporal, dtStringToDate } from "./temporal.js";
 import { splitBody, saveExtends, deleteExtends, validateExtends, readExtends } from "./extend-io.js";
 import { createRecord, updateRecord, getRecord, deleteRecord, restoreRecord, purgeRecord } from "./mutate.js";
+import { deleteRecordActivity } from "./record-activity.js";
 export class UnknownShelfError extends Error {
 }
 export const MAX_PAGE = 500;
@@ -209,6 +210,7 @@ export async function recordRestore(library, shelf, id, actor = 'gui') {
 export async function recordPurge(library, shelf, id, actor = 'gui') {
     const { m, ename } = resolve(library, shelf);
     await purgeRecord(m, ename, id, { actor }, (tx, recordId) => deleteExtends(tx, library, shelf, recordId));
+    await deleteRecordActivity(library, shelf, id);
 }
 export async function recordTrashList() {
     const shelves = getActiveRegistry().shelves.filter((s) => s.standalone !== false);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffer-org/server",
-  "version": "2.4.0",
+  "version": "2.5.1",
   "type": "module",
   "engines": {
     "node": ">=24"