@unson/brainbase-mcp 0.6.0 → 0.8.0

package/dist/local-web-security.d.ts

@@ -0,0 +1,25 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+/**
+ * Protections shared by every local single-owner Web host (the value-proof
+ * review host and the general local Web host).  They have no login, so the
+ * loopback Host check, the per-launch token and the same-origin check are the
+ * whole boundary against another site in the owner's browser.
+ */
+export declare const LOCAL_WEB_CONTENT_SECURITY_POLICY = "default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self' data:; connect-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'";
+export declare class LocalWebHttpError extends Error {
+    readonly statusCode: number;
+    readonly code: string;
+    constructor(statusCode: number, code: string, message: string);
+}
+export declare function requestUrl(request: IncomingMessage): URL;
+export declare function writeJson(response: ServerResponse, statusCode: number, body: unknown): void;
+export declare function writeHttpError(response: ServerResponse, error: LocalWebHttpError): void;
+export declare function tokenMatches(expected: string, received: string | string[] | undefined): boolean;
+/** A browser always sends Origin on a cross-site write; it must name this Host. */
+export declare function assertSameOrigin(request: IncomingMessage): void;
+/** Reads the whole body but stops as soon as it exceeds the limit. */
+export declare function readBoundedBody(request: IncomingMessage, limitBytes: number): Promise<Buffer>;
+export declare function readJsonObjectBody(request: IncomingMessage, limitBytes: number): Promise<Record<string, unknown>>;
+export declare const LOOPBACK_HOSTNAMES: readonly ["127.0.0.1", "localhost", "[::1]"];
+/** Rejects rebound DNS names: the Host must be a loopback name for the port this connection arrived on. */
+export declare function isLoopbackHost(request: IncomingMessage): boolean;

package/dist/local-web-security.js

@@ -0,0 +1,95 @@
+import { timingSafeEqual } from 'node:crypto';
+/**
+ * Protections shared by every local single-owner Web host (the value-proof
+ * review host and the general local Web host).  They have no login, so the
+ * loopback Host check, the per-launch token and the same-origin check are the
+ * whole boundary against another site in the owner's browser.
+ */
+export const LOCAL_WEB_CONTENT_SECURITY_POLICY = "default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self' data:; connect-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'";
+export class LocalWebHttpError extends Error {
+    statusCode;
+    code;
+    constructor(statusCode, code, message) {
+        super(message);
+        this.statusCode = statusCode;
+        this.code = code;
+        this.name = 'LocalWebHttpError';
+    }
+}
+export function requestUrl(request) {
+    return new URL(request.url ?? '/', 'http://localhost');
+}
+export function writeJson(response, statusCode, body) {
+    if (response.headersSent)
+        return;
+    response.statusCode = statusCode;
+    response.setHeader('Content-Type', 'application/json; charset=utf-8');
+    response.setHeader('Cache-Control', 'no-store');
+    response.setHeader('X-Content-Type-Options', 'nosniff');
+    response.end(JSON.stringify(body));
+}
+export function writeHttpError(response, error) {
+    writeJson(response, error.statusCode, { error: { code: error.code, message: error.message } });
+}
+export function tokenMatches(expected, received) {
+    if (typeof received !== 'string')
+        return false;
+    const left = Buffer.from(expected);
+    const right = Buffer.from(received);
+    return left.length === right.length && timingSafeEqual(left, right);
+}
+/** A browser always sends Origin on a cross-site write; it must name this Host. */
+export function assertSameOrigin(request) {
+    const origin = request.headers.origin;
+    if (origin === undefined)
+        return;
+    let host;
+    try {
+        host = new URL(origin).host;
+    }
+    catch {
+        throw new LocalWebHttpError(403, 'cross_origin_rejected', 'Origin is not allowed');
+    }
+    if (host !== request.headers.host)
+        throw new LocalWebHttpError(403, 'cross_origin_rejected', 'Origin is not allowed');
+}
+/** Reads the whole body but stops as soon as it exceeds the limit. */
+export async function readBoundedBody(request, limitBytes) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > limitBytes)
+            throw new LocalWebHttpError(413, 'payload_too_large', 'Request body is too large');
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks);
+}
+export async function readJsonObjectBody(request, limitBytes) {
+    const contentType = String(request.headers['content-type'] ?? '');
+    if (!contentType.toLowerCase().startsWith('application/json')) {
+        throw new LocalWebHttpError(415, 'unsupported_media_type', 'Content-Type must be application/json');
+    }
+    const body = await readBoundedBody(request, limitBytes);
+    let value;
+    try {
+        value = JSON.parse(body.toString('utf8'));
+    }
+    catch {
+        throw new LocalWebHttpError(400, 'invalid_json', 'Request body must be JSON');
+    }
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new LocalWebHttpError(400, 'invalid_json', 'Request body must be a JSON object');
+    }
+    return value;
+}
+export const LOOPBACK_HOSTNAMES = ['127.0.0.1', 'localhost', '[::1]'];
+/** Rejects rebound DNS names: the Host must be a loopback name for the port this connection arrived on. */
+export function isLoopbackHost(request) {
+    const host = request.headers.host?.toLowerCase();
+    const port = request.socket.localPort;
+    if (host === undefined || port === undefined)
+        return false;
+    return LOOPBACK_HOSTNAMES.some((name) => host === `${name}:${port}` || (port === 80 && host === name));
+}

package/dist/ontology-foundation.d.ts

@@ -0,0 +1,209 @@
+/**
+ * Shared semantic contract for the company judgment foundation.
+ *
+ * This module is intentionally separate from the historical Graph entity
+ * kinds.  Story 01 registers the definitions that a later canonical store can
+ * adopt; it does not reinterpret or mutate ontology releases 1.0.0/2.0.0.
+ */
+export declare const JUDGMENT_FOUNDATION_CONTRACT_VERSION: "0.1.0";
+export type FoundationType = 'objective' | 'variable' | 'model' | 'constraint';
+export type FoundationUse = 'draft' | 'judgment' | 'evaluation' | 'execution';
+export type FoundationEpistemicState = 'unverified' | 'hypothesis' | 'supported' | 'verified' | 'refuted';
+export type FoundationAdoptionState = 'draft' | 'proposed' | 'approved' | 'retired';
+/** `ontology` means a formal definition in the future canonical store. */
+export type FoundationStorage = 'candidate' | 'ontology' | 'evidence' | 'execution';
+export type FoundationValueKind = 'number' | 'boolean' | 'string' | 'state';
+export type FoundationAggregation = 'none' | 'sum' | 'average' | 'count' | 'min' | 'max' | 'last' | 'custom';
+/**
+ * Threshold operators are intentionally the only operators in the first
+ * contract.  Relative increase/decrease/maintain need a versioned baseline;
+ * accepting them without one would make an evaluation criterion ambiguous.
+ */
+export type FoundationOperator = 'at_least' | 'at_most' | 'equals';
+export type FoundationValidationState = 'unverified' | 'in_progress' | 'supported' | 'verified' | 'refuted';
+export interface FoundationRevision {
+    id: string;
+    type: FoundationType;
+    revision: string;
+}
+export interface DecisionRevision {
+    id: string;
+    type: 'decision';
+    revision: string;
+}
+export type RevisionReference = FoundationRevision | DecisionRevision;
+export interface FoundationPeriod {
+    from: string;
+    until: string;
+}
+export interface FoundationScope {
+    subjectIds: readonly string[];
+    validFrom: string;
+    validUntil?: string;
+}
+export interface FoundationAcl {
+    /** The owner is explicit even when visibility is public. */
+    ownerId: string;
+    visibility: 'private' | 'project' | 'organization' | 'public';
+    readerIds: readonly string[];
+    writerIds: readonly string[];
+}
+export interface FoundationProvenance {
+    sourceId: string;
+    sourceKind: 'candidate' | 'document' | 'observation' | 'decision' | 'import';
+    evidenceIds: readonly string[];
+}
+export interface FoundationDefinitionBase {
+    id: string;
+    type: FoundationType;
+    revision: string;
+    meaning: string;
+    /** Objective, Variable, and Constraint may be epistemically open in a draft. */
+    epistemicState?: FoundationEpistemicState;
+    adoptionState: FoundationAdoptionState;
+    authorizedUses: readonly FoundationUse[];
+    acl: FoundationAcl;
+    /** Storage is a destination contract, not a confidence or truth value. */
+    storage: FoundationStorage;
+    provenance: readonly FoundationProvenance[];
+    scope: FoundationScope;
+}
+export interface ObjectiveCriterion {
+    variableRef: FoundationRevision;
+    operator: FoundationOperator;
+    target?: string | number | boolean;
+}
+export interface ObjectiveDefinition extends FoundationDefinitionBase {
+    type: 'objective';
+    beneficiaryIds: readonly string[];
+    desiredState: string;
+    criteria: readonly ObjectiveCriterion[];
+    evaluationPeriod: FoundationPeriod;
+    accountableId?: string;
+}
+export interface VariableDefinition extends FoundationDefinitionBase {
+    type: 'variable';
+    subject: string;
+    valueKind: FoundationValueKind;
+    unit?: string;
+    aggregation: FoundationAggregation;
+    granularity: string;
+    measurementMethod: string;
+}
+export interface ModelDefinition extends FoundationDefinitionBase {
+    type: 'model';
+    /** A model is allowed to be formally registered while still unverified. */
+    epistemicState: FoundationEpistemicState;
+    inputVariableRefs: readonly FoundationRevision[];
+    outputVariableRefs: readonly FoundationRevision[];
+    applicability: FoundationScope;
+    relationship: string;
+    uncertainty: string;
+    validationState: FoundationValidationState;
+}
+export interface ConstraintException {
+    decisionRef: DecisionRevision;
+    scope: FoundationScope;
+}
+export interface ConstraintDefinition extends FoundationDefinitionBase {
+    type: 'constraint';
+    condition: string;
+    appliesTo: readonly string[];
+    exceptions: readonly ConstraintException[];
+    adoptionBasis: readonly DecisionRevision[];
+}
+export type FoundationDefinition = ObjectiveDefinition | VariableDefinition | ModelDefinition | ConstraintDefinition;
+export type FoundationRelationId = 'contributes_to' | 'execution_depends_on' | 'time_condition' | 'evaluated_by' | 'uses_as_input' | 'predicts' | 'applies_to' | 'used_as_basis';
+export type FoundationTimeConditionKind = 'deadline' | 'evaluation_window';
+export interface FoundationTimeCondition {
+    kind: FoundationTimeConditionKind;
+    period: FoundationPeriod;
+}
+export type FoundationRelationEndpoint = FoundationType | 'story' | 'decision' | 'project' | 'judgment_problem' | 'execution' | 'outcome' | 'evaluation';
+export interface FoundationRelationDefinition {
+    id: FoundationRelationId;
+    from: readonly FoundationRelationEndpoint[];
+    to: readonly FoundationRelationEndpoint[];
+    meaning: string;
+    permittedInferences: readonly string[];
+    prohibitedInferences: readonly string[];
+}
+export interface FoundationRelationReference {
+    relation: FoundationRelationId;
+    source: FoundationRevision | DecisionRevision | {
+        id: string;
+        type: FoundationRelationEndpoint;
+        revision?: string;
+    };
+    target: FoundationRevision | DecisionRevision | {
+        id: string;
+        type: FoundationRelationEndpoint;
+        revision?: string;
+    };
+    /** Required only by `time_condition`; forbidden for other relation kinds. */
+    timeCondition?: FoundationTimeCondition;
+}
+export interface FoundationValidationIssue {
+    code: 'MISSING_FIELD' | 'INVALID_FIELD' | 'INVALID_REVISION_REFERENCE' | 'UNAUTHORIZED_USE' | 'UNVERIFIED_MODEL' | 'EVALUATION_DEFINITION_VERSION_MISMATCH' | 'EVALUATION_UNIT_MISMATCH' | 'EVALUATION_AGGREGATION_MISMATCH' | 'EVALUATION_GRANULARITY_MISMATCH' | 'EVALUATION_SCOPE_MISMATCH' | 'EVALUATION_PERIOD_MISMATCH' | 'RELATION_SOURCE_TYPE_MISMATCH' | 'RELATION_TARGET_TYPE_MISMATCH';
+    path: string;
+    message: string;
+}
+export interface FoundationValidationResult {
+    valid: boolean;
+    status: 'valid' | 'invalid' | 'unverified';
+    issues: readonly FoundationValidationIssue[];
+}
+export interface FoundationEvaluationDescriptor {
+    variableRef: FoundationRevision;
+    unit?: string;
+    aggregation: FoundationAggregation;
+    granularity: string;
+    scope: FoundationScope;
+    period: FoundationPeriod;
+}
+export interface FoundationEvaluationExpectation {
+    scope?: FoundationScope;
+    period?: FoundationPeriod;
+}
+export interface FoundationTypeContract {
+    type: FoundationType;
+    meaning: string;
+    /** Fields supplied by the shared definition base for every non-draft use. */
+    requiredBase: readonly string[];
+    /** Type-specific fields required for the named use. */
+    requiredForJudgment: readonly string[];
+    requiredForEvaluation: readonly string[];
+    /** Conditional requirements that cannot be represented by one flat list. */
+    conditionalRequirements?: readonly string[];
+}
+export interface JudgmentFoundationContract {
+    version: typeof JUDGMENT_FOUNDATION_CONTRACT_VERSION;
+    status: 'extension-manifest';
+    compatibility: 'read-compatible-write-gated';
+    historicalOntologyVersions: readonly ['1.0.0', '2.0.0'];
+    canonicalStoreAdoption: 'future-story-02-plus';
+    graphActivation: 'deferred';
+    types: Readonly<Record<FoundationType, FoundationTypeContract>>;
+    relations: Readonly<Record<FoundationRelationId, FoundationRelationDefinition>>;
+    inference: {
+        worldModelCycles: 'allowed';
+        executionDagCycles: 'rejected';
+    };
+}
+export declare const judgmentFoundationRelations: Readonly<Record<FoundationRelationId, FoundationRelationDefinition>>;
+/**
+ * Extension manifest consumed by future canonical-store work.  The historical
+ * portable ontology releases intentionally do not include these definitions.
+ */
+export declare const judgmentFoundationContract: JudgmentFoundationContract;
+export declare function validateFoundationDefinition(definition: unknown, options: {
+    use: FoundationUse;
+}): FoundationValidationResult;
+export declare function validateFoundationRelation(reference: unknown): FoundationValidationResult;
+export declare function validateEvaluationCompatibility(variable: unknown, actual: unknown, expected?: unknown): FoundationValidationResult;
+/**
+ * Relation declarations carry no achievement, causality, accuracy, or truth
+ * inference.  This intentionally returns no derived conclusions; callers must
+ * use explicit observations, evaluations, or decisions for those claims.
+ */
+export declare function inferFoundationConclusions(reference: unknown): readonly [];