@unson/brainbase-mcp 0.7.0 → 0.8.0

package/dist/local-web-fetch-bridge.d.ts

@@ -0,0 +1,5 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare function nodeRequestToFetch(request: IncomingMessage, options: {
+    readonly limitBytes: number;
+}): Promise<Request>;
+export declare function writeFetchResponse(response: ServerResponse, fetchResponse: Response): Promise<void>;

package/dist/local-web-fetch-bridge.js

@@ -0,0 +1,37 @@
+import { readBoundedBody } from './local-web-security.js';
+/**
+ * Minimal bridge between a Node `http` request and a Fetch-style handler such
+ * as `createFoundationHttpRouter().handle`.  Only the headers those handlers
+ * read are forwarded; the Host, Origin and token were already checked on the
+ * Node request, which stays the security boundary.
+ */
+const FORWARDED_HEADERS = ['accept', 'content-type', 'if-match'];
+export async function nodeRequestToFetch(request, options) {
+    const method = (request.method ?? 'GET').toUpperCase();
+    const headers = new Headers();
+    for (const name of FORWARDED_HEADERS) {
+        const value = request.headers[name];
+        if (typeof value === 'string')
+            headers.set(name, value);
+    }
+    const url = new URL(request.url ?? '/', 'http://localhost');
+    if (method === 'GET' || method === 'HEAD')
+        return new Request(url, { method, headers });
+    // The body is read here with the host's limit so an oversized request is
+    // rejected before the whole stream is buffered by the Fetch handler.
+    const body = await readBoundedBody(request, options.limitBytes);
+    return new Request(url, { method, headers, body: new Uint8Array(body) });
+}
+export async function writeFetchResponse(response, fetchResponse) {
+    if (response.headersSent)
+        return;
+    response.statusCode = fetchResponse.status;
+    for (const name of ['content-type', 'allow']) {
+        const value = fetchResponse.headers.get(name);
+        if (value !== null)
+            response.setHeader(name, value);
+    }
+    response.setHeader('Cache-Control', 'no-store');
+    response.setHeader('X-Content-Type-Options', 'nosniff');
+    response.end(Buffer.from(await fetchResponse.arrayBuffer()));
+}

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

@@ -0,0 +1,109 @@
+import { type IncomingMessage, type Server, type ServerResponse } from 'node:http';
+import { type ObjectiveDefinitionBuilder } from './foundation-http.js';
+/**
+ * General local single-owner Web host (`brainbase web:serve`).
+ *
+ * One loopback server carries every local screen.  The host owns the
+ * protections, the trusted principal and the static allowlist; each screen's
+ * server side is a `LocalWebModule`.  To add a screen, add its module to
+ * `defaultLocalWebModules()` and its nav entry to `LOCAL_WEB_SCREENS` in
+ * `ui/local-web-shell.js`.
+ */
+export declare const LOCAL_WEB_HOST_VERSION: "local-web-host.v1";
+/** One per-launch token guards every write on this host, including value-proof feedback. */
+export declare const LOCAL_WEB_TOKEN_HEADER = "x-brainbase-review-token";
+export declare const LOCAL_WEB_DEFAULT_PORT = 31080;
+/** Onboarding registers the owner as `self`; a graph without an owner id uses the same principal. */
+export declare const LOCAL_WEB_DEFAULT_OWNER_ID = "self";
+export declare const LOCAL_WEB_STATUS_PATH = "/api/local/status";
+export declare const LOCAL_WEB_WORLD_MODEL_PREFIX = "/api/world-model";
+export declare const LOCAL_WEB_GRAPH_PREFIX = "/api/graph";
+/**
+ * An Objective is a few KB of text and criteria.  64 KiB leaves room for long
+ * Japanese text (about 20k characters) while keeping a loopback request that
+ * holds the SSOT lock far below the Fetch router's 1 MiB default.
+ */
+export declare const LOCAL_WEB_FOUNDATION_BODY_LIMIT_BYTES: number;
+export declare const LOCAL_WEB_PROVENANCE_SOURCE_ID = "brainbase-local-web";
+export type LocalGraphStatus = 'ready' | 'migration_required' | 'not_initialized' | 'unreadable';
+export interface LocalGraphState {
+    readonly status: LocalGraphStatus;
+    readonly format: 'v1' | 'v2' | null;
+    /** Trusted principal for Foundation/World Model access. Never read from the browser. */
+    readonly ownerId: string | null;
+    readonly message?: string;
+}
+export interface LocalWebModuleContext {
+    readonly dataDir: string;
+    readonly journalRoot: string;
+    readonly token: string;
+    readonly now: () => Date;
+}
+/**
+ * Server side of one screen.  The host has already rejected a non-loopback
+ * Host and every non-GET request without the launch token and same origin
+ * before `handle` runs.  `handle` returns false for a path it does not own.
+ */
+export interface LocalWebModule {
+    readonly id: string;
+    /** Packaged `ui/` file names the screen loads.  Only listed files are served. */
+    readonly uiFiles: readonly string[];
+    handle(request: IncomingMessage, response: ServerResponse): Promise<boolean>;
+}
+export interface LocalWebHostOptions {
+    /** Personal OS data directory. Defaults to `BRAINBASE_PERSONAL_OS_DIR` or `~/.brainbase/personal-os`. */
+    readonly dataDir?: string;
+    /** Judgment journal root. Defaults to the journal inside the data directory. */
+    readonly journalRoot?: string;
+    readonly token?: string;
+    /** Directory containing the packaged `ui/` files. */
+    readonly uiDir?: string;
+    readonly now?: () => Date;
+}
+export interface LocalWebHost {
+    readonly server: Server;
+    readonly token: string;
+    readonly dataDir: string;
+    readonly journalRoot: string;
+}
+/** True only for a write that carries the launch token from this origin. */
+export declare function isTrustedLocalWrite(request: IncomingMessage, token: string): boolean;
+/** Reads the Graph format and owner without creating or migrating anything. */
+export declare function readLocalGraphState(dataDir: string): Promise<LocalGraphState>;
+export declare function createLocalStatusModule(context: LocalWebModuleContext): LocalWebModule;
+export declare function createValueProofModule(context: LocalWebModuleContext): LocalWebModule;
+/**
+ * Trusted authority fields for a single owner.  The owner writes through the
+ * launch-token browser session, so a new Objective is private to the owner,
+ * scoped to the owner, and usable for drafting, judgment and evaluation.  It is
+ * never authorized for execution from the Web.  Updates keep every authority
+ * field byte-identical to the current revision.
+ */
+export declare function createLocalObjectiveDefinitionBuilder(now: () => Date): ObjectiveDefinitionBuilder;
+/**
+ * Objective routes of `createObjectiveFoundationRoute`, wired to the local
+ * Graph.  The principal is the Graph owner; the CSRF verifier is the host's
+ * token and same-origin check on the original Node request.  Constraint links
+ * are read-only because no OSS writer can replace them.
+ */
+export declare function createObjectiveFoundationModule(context: LocalWebModuleContext): LocalWebModule;
+/**
+ * Read-only World Model routes.  Writes (observations, corrections, model
+ * adoption) are not on the Web in v1.  Without an approval reader an approved
+ * adoption cannot be verified, so only the adoptions route reports
+ * `approval_reference_unresolved`; the other routes stay readable.
+ */
+export declare function createWorldModelReadModule(context: LocalWebModuleContext): LocalWebModule;
+/**
+ * 「プロジェクトと関係者」 and 「情報と関係」: the local Graph read and correction
+ * routes under `/api/graph`.  Graph v1 and a missing data set are answered by
+ * the handler itself (`migration_required` / `not_initialized`), never as zero
+ * items.  The host has already required the launch token and the same origin
+ * for every write; the handler checks both again before it reads a body, so a
+ * correction is never saved through a path that skipped the host check.
+ */
+export declare function createGraphWebModule(context: LocalWebModuleContext): LocalWebModule;
+/** 今日 (value proofs), 目的と現状 (objectives + world model), プロジェクトと関係者 and 情報と関係 (Graph). */
+export declare function defaultLocalWebModules(context: LocalWebModuleContext): LocalWebModule[];
+/** Local single-owner host. The caller owns `listen()` and must bind to a loopback address. */
+export declare function createLocalWebHost(options?: LocalWebHostOptions): LocalWebHost;