@unson/brainbase-mcp 0.10.15 → 0.11.0

package/dist/server-support.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Small HTTP-host helpers shared by Brainbase servers: a structured error with
+ * client-safe JSON, an async route wrapper, and a JSON logger that masks
+ * secrets. They carry no organization, tenant, or deployment concept.
+ */
+type UnknownRecord = Record<string, unknown>;
+export interface ErrorCodeEntry {
+    code: string;
+    statusCode: number;
+}
+/** Standard error codes. `code` is safe to expose to clients. */
+export declare const ErrorCodes: {
+    VALIDATION_ERROR: {
+        code: string;
+        statusCode: number;
+    };
+    INVALID_DATE_FORMAT: {
+        code: string;
+        statusCode: number;
+    };
+    MISSING_REQUIRED_FIELD: {
+        code: string;
+        statusCode: number;
+    };
+    UNSUPPORTED_FORMAT: {
+        code: string;
+        statusCode: number;
+    };
+    UNAUTHORIZED: {
+        code: string;
+        statusCode: number;
+    };
+    FORBIDDEN: {
+        code: string;
+        statusCode: number;
+    };
+    CROSS_TENANT_CANDIDATE: {
+        code: string;
+        statusCode: number;
+    };
+    PROJECT_NOT_FOUND: {
+        code: string;
+        statusCode: number;
+    };
+    SESSION_NOT_FOUND: {
+        code: string;
+        statusCode: number;
+    };
+    TASK_NOT_FOUND: {
+        code: string;
+        statusCode: number;
+    };
+    SCHEDULE_NOT_FOUND: {
+        code: string;
+        statusCode: number;
+    };
+    WORKTREE_NOT_FOUND: {
+        code: string;
+        statusCode: number;
+    };
+    EVENT_NOT_FOUND: {
+        code: string;
+        statusCode: number;
+    };
+    CONFLICT: {
+        code: string;
+        statusCode: number;
+    };
+    PORT_IN_USE: {
+        code: string;
+        statusCode: number;
+    };
+    INTERNAL_ERROR: {
+        code: string;
+        statusCode: number;
+    };
+    DATABASE_ERROR: {
+        code: string;
+        statusCode: number;
+    };
+    PROJECT_CATALOG_UNAVAILABLE: {
+        code: string;
+        statusCode: number;
+    };
+    TIMEOUT: {
+        code: string;
+        statusCode: number;
+    };
+};
+export interface AppErrorOptions {
+    details?: UnknownRecord | null;
+    cause?: unknown;
+}
+export interface AppErrorLog {
+    code: string;
+    message: string;
+    statusCode: number;
+    timestamp: string;
+    details?: UnknownRecord;
+    cause?: string;
+}
+/** A structured error: the message and code go to clients, details stay in logs. */
+export declare class AppError extends Error {
+    readonly code: string;
+    readonly statusCode: number;
+    readonly timestamp: string;
+    readonly details: UnknownRecord | null;
+    cause?: unknown;
+    constructor(message: string, errorCode: ErrorCodeEntry, options?: AppErrorOptions);
+    /** Client-safe JSON. It never includes details. */
+    toJSON(): {
+        error: {
+            code: string;
+            message: string;
+            timestamp: string;
+        };
+    };
+    /** Log object, including details and the cause message. */
+    toLog(): AppErrorLog;
+    static isAppError(error: unknown): error is AppError;
+    static notFound(resource: string, id: string): AppError;
+    static validation(message: string, details?: UnknownRecord): AppError;
+    static unauthorized(message?: string): AppError;
+    static forbidden(message?: string, details?: UnknownRecord): AppError;
+    static conflict(message: string, details?: UnknownRecord): AppError;
+    static internal(message?: string, cause?: Error): AppError;
+}
+type RouteHandler = (req: any, res: any, next: (error?: unknown) => unknown) => unknown;
+/** Wraps an async route handler so that a rejection reaches the error middleware. */
+export declare function asyncHandler(fn: RouteHandler): (req: any, res: any, next: (error?: unknown) => unknown) => void;
+/** JSON-line logger that masks secrets. DEBUG enables debug lines. */
+export declare const logger: {
+    info(msg: string, data?: UnknownRecord): void;
+    warn(msg: string, data?: UnknownRecord): void;
+    error(msg: string, data?: Error | (UnknownRecord & {
+        error?: unknown;
+    })): void;
+    debug(msg: string, data?: UnknownRecord): void;
+};
+export {};

package/dist/server-support.js

@@ -0,0 +1,158 @@
+/**
+ * Small HTTP-host helpers shared by Brainbase servers: a structured error with
+ * client-safe JSON, an async route wrapper, and a JSON logger that masks
+ * secrets. They carry no organization, tenant, or deployment concept.
+ */
+/** Standard error codes. `code` is safe to expose to clients. */
+export const ErrorCodes = {
+    VALIDATION_ERROR: { code: 'VALIDATION_ERROR', statusCode: 400 },
+    INVALID_DATE_FORMAT: { code: 'INVALID_DATE_FORMAT', statusCode: 400 },
+    MISSING_REQUIRED_FIELD: { code: 'MISSING_REQUIRED_FIELD', statusCode: 400 },
+    UNSUPPORTED_FORMAT: { code: 'UNSUPPORTED_FORMAT', statusCode: 400 },
+    UNAUTHORIZED: { code: 'UNAUTHORIZED', statusCode: 401 },
+    FORBIDDEN: { code: 'FORBIDDEN', statusCode: 403 },
+    CROSS_TENANT_CANDIDATE: { code: 'CROSS_TENANT_CANDIDATE', statusCode: 403 },
+    PROJECT_NOT_FOUND: { code: 'PROJECT_NOT_FOUND', statusCode: 404 },
+    SESSION_NOT_FOUND: { code: 'SESSION_NOT_FOUND', statusCode: 404 },
+    TASK_NOT_FOUND: { code: 'TASK_NOT_FOUND', statusCode: 404 },
+    SCHEDULE_NOT_FOUND: { code: 'SCHEDULE_NOT_FOUND', statusCode: 404 },
+    WORKTREE_NOT_FOUND: { code: 'WORKTREE_NOT_FOUND', statusCode: 404 },
+    EVENT_NOT_FOUND: { code: 'EVENT_NOT_FOUND', statusCode: 404 },
+    CONFLICT: { code: 'CONFLICT', statusCode: 409 },
+    PORT_IN_USE: { code: 'PORT_IN_USE', statusCode: 409 },
+    INTERNAL_ERROR: { code: 'INTERNAL_ERROR', statusCode: 500 },
+    DATABASE_ERROR: { code: 'DATABASE_ERROR', statusCode: 500 },
+    PROJECT_CATALOG_UNAVAILABLE: { code: 'PROJECT_CATALOG_UNAVAILABLE', statusCode: 503 },
+    TIMEOUT: { code: 'TIMEOUT', statusCode: 504 },
+};
+/** A structured error: the message and code go to clients, details stay in logs. */
+export class AppError extends Error {
+    code;
+    statusCode;
+    timestamp;
+    details;
+    cause;
+    constructor(message, errorCode, options = {}) {
+        super(message);
+        this.name = 'AppError';
+        this.code = errorCode.code;
+        this.statusCode = errorCode.statusCode;
+        this.timestamp = new Date().toISOString();
+        this.details = options.details || null;
+        if (options.cause)
+            this.cause = options.cause;
+    }
+    /** Client-safe JSON. It never includes details. */
+    toJSON() {
+        return { error: { code: this.code, message: this.message, timestamp: this.timestamp } };
+    }
+    /** Log object, including details and the cause message. */
+    toLog() {
+        const log = {
+            code: this.code,
+            message: this.message,
+            statusCode: this.statusCode,
+            timestamp: this.timestamp,
+        };
+        if (this.details)
+            log.details = this.details;
+        if (this.cause)
+            log.cause = this.cause instanceof Error ? this.cause.message : String(this.cause);
+        return log;
+    }
+    static isAppError(error) {
+        return error instanceof AppError;
+    }
+    static notFound(resource, id) {
+        const dynamicCode = ErrorCodes[`${resource.toUpperCase()}_NOT_FOUND`];
+        return new AppError(`${resource} '${id}' not found`, dynamicCode || ErrorCodes.SESSION_NOT_FOUND);
+    }
+    static validation(message, details) {
+        return new AppError(message, ErrorCodes.VALIDATION_ERROR, { details });
+    }
+    static unauthorized(message = 'Unauthorized') {
+        return new AppError(message, ErrorCodes.UNAUTHORIZED);
+    }
+    static forbidden(message = 'Forbidden', details) {
+        return new AppError(message, ErrorCodes.FORBIDDEN, { details });
+    }
+    static conflict(message, details) {
+        return new AppError(message, ErrorCodes.CONFLICT, { details });
+    }
+    static internal(message = 'Internal server error', cause) {
+        return new AppError(message, ErrorCodes.INTERNAL_ERROR, { cause });
+    }
+}
+/** Wraps an async route handler so that a rejection reaches the error middleware. */
+export function asyncHandler(fn) {
+    return (req, res, next) => {
+        Promise.resolve(fn(req, res, next)).catch((error) => {
+            next(error);
+        });
+    };
+}
+const SENSITIVE_KEYS = [
+    'password', 'token', 'secret', 'key', 'credential', 'auth', 'apikey', 'api_key',
+    'access_token', 'refresh_token', 'private', 'cookie', 'session',
+];
+const SENSITIVE_PATH_PATTERNS = [/\/\.env/, /\/credentials/, /\/secrets/, /\/\.ssh/, /\/\.gnupg/];
+function redact(value, depth = 0) {
+    if (depth > 10)
+        return '[MAX_DEPTH]';
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value !== 'object') {
+        if (typeof value === 'string') {
+            if (/^eyJ[a-zA-Z0-9_-]+\.eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+$/.test(value))
+                return '[JWT_REDACTED]';
+            if (/^[a-fA-F0-9]{32,}$/.test(value))
+                return '[HEX_KEY_REDACTED]';
+            if (SENSITIVE_PATH_PATTERNS.some((pattern) => pattern.test(value)))
+                return '[SENSITIVE_PATH_REDACTED]';
+        }
+        return value;
+    }
+    if (Array.isArray(value))
+        return value.map((item) => redact(item, depth + 1));
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+        const lowerKey = key.toLowerCase();
+        result[key] = SENSITIVE_KEYS.some((sensitive) => lowerKey.includes(sensitive)) ? '[REDACTED]' : redact(item, depth + 1);
+    }
+    return result;
+}
+function formatLog(level, msg, data = {}) {
+    const masked = redact(data);
+    return JSON.stringify({
+        timestamp: new Date().toISOString(),
+        level,
+        msg,
+        ...(masked && typeof masked === 'object' && !Array.isArray(masked) ? masked : {}),
+    });
+}
+/** JSON-line logger that masks secrets. DEBUG enables debug lines. */
+export const logger = {
+    info(msg, data = {}) {
+        console.log(formatLog('info', msg, data));
+    },
+    warn(msg, data = {}) {
+        console.warn(formatLog('warn', msg, data));
+    },
+    error(msg, data = {}) {
+        let entry;
+        if (data instanceof Error) {
+            entry = { error: data.message, stack: data.stack };
+        }
+        else if (data.error instanceof Error) {
+            entry = { ...data, error: data.error.message, stack: data.error.stack };
+        }
+        else {
+            entry = data;
+        }
+        console.error(formatLog('error', msg, entry));
+    },
+    debug(msg, data = {}) {
+        if (process.env.DEBUG)
+            console.log(formatLog('debug', msg, data));
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.10.15",
+  "version": "0.11.0",
   "description": "Local-first Brainbase judgment OS that lets supported AI agents reuse a user's approved goals, priorities, decisions, and judgment criteria.",
   "type": "module",
   "license": "MIT",
@@ -191,6 +191,10 @@
       "types": "./dist/execution-authority-http.d.ts",
       "import": "./dist/execution-authority-http.js"
     },
+    "./server-support": {
+      "types": "./dist/server-support.d.ts",
+      "import": "./dist/server-support.js"
+    },
     "./company-os-impact-review": {
       "types": "./dist/company-os-impact-review.d.ts",
       "import": "./dist/company-os-impact-review.js"
@@ -344,5 +348,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "04f1192c75877ca241970ee379c274e37c6693cc"
+  "gitHead": "070f39f8014fbbe224bb4615ef89999aeeb8d0a5"
 }