@anteros/core 0.0.28 → 0.0.31

package/database/decorator.ts

@@ -22,7 +22,7 @@ export function LogSlowQuery(): any {
                 const duration = performance.now() - start;
                 const slowMs = cfg.server.logging?.slowQueryMs ?? 200;
                 if (duration >= slowMs) {
-                    logger.warn(`Slow ${propertyKey} (${Math.round(duration)}ms)`, {
+                    logger.file('warn', `Slow ${propertyKey} (${Math.round(duration)}ms)`, {
                         collection: args[0],
                         tenant: this.tenant_id,
                         duration: Math.round(duration),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@anteros/core",
   "module": "index.ts",
-  "version": "0.0.28",
+  "version": "0.0.31",
   "type": "module",
   "description": "Anteros Core",
   "private": false,

package/server/boot.ts

@@ -177,7 +177,8 @@ async function bootApp(options: BootAppOptions = {} as BootAppOptions) {
                         const remote: any = (server as any).requestIP?.(req);
                         const remoteIp = remote?.address ?? null;
                         const remotePort = remote?.port ?? null;
-                        logger.info(`${req.method} ${url.pathname}${url.search} → ${res.status}`, {
+                        // File-only: same as the API access log, no console noise.
+                        logger.file(`${req.method} ${url.pathname}${url.search} → ${res.status}`, {
                             logger: 'http.log.access',
                             status: res.status,
                             duration: Math.round((performance.now() - start) * 10) / 10,

package/server/hono.ts

@@ -234,7 +234,8 @@ function createApp(): Hono<{ Variables: HonoVariables }> {
             const remoteIp = conn?.remote?.address ?? null;
             const remotePort = conn?.remote?.port ?? null;
 
-            logger.info(`${c.req.method} ${uri} → ${c.res.status}`, {
+            // File-only: the per-request access log would flood the console.
+            logger.file(`${c.req.method} ${uri} → ${c.res.status}`, {
                 logger: 'http.log.access',
                 status: c.res.status,
                 duration: Math.round(duration * 10) / 10,

package/server/mcp.ts

@@ -124,7 +124,7 @@ function buildServer(tenantId: string, tools: McpTool[], resources: McpResource[
             description: t.description,
             inputSchema: joiToJsonSchema(t.inputSchema),
         }));
-        logger.info('MCP tools/list', { method: 'tools/list', tenant: tenantId, count: toolsList.length, duration: ms(start) });
+        logger.file('MCP tools/list', { method: 'tools/list', tenant: tenantId, count: toolsList.length, duration: ms(start) });
         return { tools: toolsList };
     });
 
@@ -132,14 +132,14 @@ function buildServer(tenantId: string, tools: McpTool[], resources: McpResource[
         const start = performance.now();
         const tool = tools.find((t) => t.name === req.params.name);
         if (!tool) {
-            logger.warn('MCP tools/call', { method: 'tools/call', tenant: tenantId, tool: req.params.name, error: 'unknown tool', duration: ms(start) });
+            logger.file('warn', 'MCP tools/call', { method: 'tools/call', tenant: tenantId, tool: req.params.name, error: 'unknown tool', duration: ms(start) });
             throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${req.params.name}`);
         }
 
         const raw = req.params.arguments ?? {};
         const { error, value } = tool.inputSchema.validate(raw, { allowUnknown: false });
         if (error) {
-            logger.warn('MCP tools/call', { method: 'tools/call', tenant: tenantId, tool: req.params.name, args: raw, error: 'invalid arguments', duration: ms(start) });
+            logger.file('warn', 'MCP tools/call', { method: 'tools/call', tenant: tenantId, tool: req.params.name, args: raw, error: 'invalid arguments', duration: ms(start) });
             return {
                 content: [{ type: 'text' as const, text: `Invalid arguments: ${error.message}` }],
                 isError: true,
@@ -155,7 +155,7 @@ function buildServer(tenantId: string, tools: McpTool[], resources: McpResource[
             const text = typeof result === 'string' ? result : JSON.stringify(result);
             return { content: [{ type: 'text' as const, text }] };
         } catch (err: any) {
-            logger.warn('MCP tools/call', { method: 'tools/call', tenant: tenantId, tool: req.params.name, args: value, error: err?.message ?? 'unknown', duration: ms(start) });
+            logger.file('warn', 'MCP tools/call', { method: 'tools/call', tenant: tenantId, tool: req.params.name, args: value, error: err?.message ?? 'unknown', duration: ms(start) });
             return {
                 content: [{ type: 'text' as const, text: `Error: ${err?.message ?? 'unknown'}` }],
                 isError: true,
@@ -173,7 +173,7 @@ function buildServer(tenantId: string, tools: McpTool[], resources: McpResource[
                 description: r.description,
                 mimeType: r.mimeType,
             }));
-        logger.info('MCP resources/list', { method: 'resources/list', tenant: tenantId, count: resourcesList.length, duration: ms(start) });
+        logger.file('MCP resources/list', { method: 'resources/list', tenant: tenantId, count: resourcesList.length, duration: ms(start) });
         return { resources: resourcesList };
     });
 
@@ -187,7 +187,7 @@ function buildServer(tenantId: string, tools: McpTool[], resources: McpResource[
                 description: r.description,
                 mimeType: r.mimeType,
             }));
-        logger.info('MCP resources/templates/list', { method: 'resources/templates/list', tenant: tenantId, count: templates.length, duration: ms(start) });
+        logger.file('MCP resources/templates/list', { method: 'resources/templates/list', tenant: tenantId, count: templates.length, duration: ms(start) });
         return { resourceTemplates: templates };
     });
 
@@ -196,7 +196,7 @@ function buildServer(tenantId: string, tools: McpTool[], resources: McpResource[
         const uri = req.params.uri;
         const matched = matchUri(uri, resources);
         if (!matched) {
-            logger.warn('MCP resources/read', { method: 'resources/read', tenant: tenantId, uri, error: 'unknown uri', duration: ms(start) });
+            logger.file('warn', 'MCP resources/read', { method: 'resources/read', tenant: tenantId, uri, error: 'unknown uri', duration: ms(start) });
             throw new McpError(ErrorCode.InvalidParams, `Unknown resource URI: ${uri}`);
         }
 
@@ -208,10 +208,10 @@ function buildServer(tenantId: string, tools: McpTool[], resources: McpResource[
                 params: matched.params,
                 uri,
             });
-            logger.info('MCP resources/read', { method: 'resources/read', tenant: tenantId, uri, resource: matched.resource.name, params: matched.params, duration: ms(start) });
+            logger.file('MCP resources/read', { method: 'resources/read', tenant: tenantId, uri, resource: matched.resource.name, params: matched.params, duration: ms(start) });
             return result;
         } catch (err: any) {
-            logger.warn('MCP resources/read', { method: 'resources/read', tenant: tenantId, uri, error: err?.message ?? 'unknown', duration: ms(start) });
+            logger.file('warn', 'MCP resources/read', { method: 'resources/read', tenant: tenantId, uri, error: err?.message ?? 'unknown', duration: ms(start) });
             throw new McpError(ErrorCode.InternalError, `Failed to read resource: ${err?.message ?? 'unknown'}`);
         }
     });

package/tests/logger.test.ts

@@ -121,4 +121,27 @@ describe("logger", () => {
         expect(out.some((l) => l.includes("visible info"))).toBe(true);
         expect(out.some((l) => l.includes("Server started"))).toBe(false);
     });
+
+    it("logger.file keeps the level when passed explicitly (never on console)", async () => {
+        const out: string[] = [];
+        const orig = console.log;
+        console.log = (...a: any[]) => { out.push(a.join(" ")); };
+
+        logger.configure({ dir: path.join(DIR, "filelevel"), file: true, console: true, level: "info" });
+        logger.file("default level", { a: 1 }); // 2-arg form → level 'info'
+        logger.file("warn", "explicit warn", { b: 2 }); // explicit level kept
+        logger.file("error", "explicit error", { c: 3 });
+        await flush();
+        console.log = orig;
+
+        const lines = readLogLines("filelevel/anteros.log");
+        expect(lines.find((l) => l.msg === "default level")!.level).toBe("info");
+        expect(lines.find((l) => l.msg === "explicit warn")!.level).toBe("warn");
+        expect(lines.find((l) => l.msg === "explicit warn")!.b).toBe(2);
+        expect(lines.find((l) => l.msg === "explicit error")!.level).toBe("error");
+        // never on the console, whatever the level
+        expect(out.some((l) => l.includes("default level"))).toBe(false);
+        expect(out.some((l) => l.includes("explicit warn"))).toBe(false);
+        expect(out.some((l) => l.includes("explicit error"))).toBe(false);
+    });
 });

package/utils/logger.ts

@@ -186,8 +186,20 @@ class Logger {
     warn(msg: string, meta?: unknown) { this.#write('warn', msg, meta); }
     error(msg: string, meta?: unknown) { this.#write('error', msg, meta); }
 
-    /** Write to the file only (no console output) — for events that would clutter the terminal */
-    file(msg: string, meta?: unknown) { this.#write('info', msg, meta, { console: false }); }
+    /**
+     * Write to the file only (no console output) — for framework-internal events
+     * (access log, MCP operations, slow queries) that would clutter the terminal.
+     * Level defaults to 'info'; `file('warn', msg, meta)` keeps the level.
+     */
+    file(msg: string, meta?: unknown): void;
+    file(level: LogLevel, msg: string, meta?: unknown): void;
+    file(levelOrMsg: LogLevel | string, msgOrMeta?: unknown, meta?: unknown): void {
+        if (levelOrMsg === 'debug' || levelOrMsg === 'info' || levelOrMsg === 'warn' || levelOrMsg === 'error') {
+            this.#write(levelOrMsg, msgOrMeta as string, meta, { console: false });
+        } else {
+            this.#write('info', levelOrMsg, msgOrMeta, { console: false });
+        }
+    }
 
     /** Current log file path (empty when file logging is disabled) */
     get filePath(): string { return this.#filePath; }