@unson/brainbase-mcp 0.44.0 → 0.44.1

package/dist/mesh.js

@@ -0,0 +1,134 @@
+import { randomUUID } from 'node:crypto';
+/** Portable mesh envelope and host-port contracts. No network or auth dependency. */
+export const MESH_CONTRACT_VERSION = 'mesh.v1';
+export const MESH_ENVELOPE_TYPES = [
+    'query',
+    'response',
+    'ping',
+    'pong',
+    'peer_joined',
+    'peer_left'
+];
+export class MeshContractError extends Error {
+    code = 'mesh_contract_invalid';
+    constructor(field, message = `mesh field is invalid: ${field}`) {
+        super(message);
+        this.name = 'MeshContractError';
+    }
+}
+function text(value, field) {
+    if (typeof value !== 'string' || !value.trim())
+        throw new MeshContractError(field);
+    return value.trim();
+}
+function isJson(value) {
+    if (value === null || ['string', 'number', 'boolean'].includes(typeof value))
+        return true;
+    if (Array.isArray(value))
+        return value.every(isJson);
+    if (typeof value === 'object')
+        return Object.values(value).every(isJson);
+    return false;
+}
+export function createMeshEnvelope(input, options = {}) {
+    const from = text(input.from, 'from');
+    const to = text(input.to, 'to');
+    if (!MESH_ENVELOPE_TYPES.includes(input.type))
+        throw new MeshContractError('type');
+    if (input.payload !== undefined && !isJson(input.payload))
+        throw new MeshContractError('payload');
+    const ts = options.now ?? Date.now();
+    if (!Number.isFinite(ts))
+        throw new MeshContractError('ts');
+    return {
+        id: options.idFactory?.() ?? randomUUID(),
+        from,
+        to,
+        type: input.type,
+        payload: input.payload ?? null,
+        ts,
+        nonce: options.nonceFactory?.() ?? randomUUID()
+    };
+}
+export function normalizeMeshEnvelope(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new MeshContractError('envelope');
+    const candidate = value;
+    const from = text(candidate.from, 'from');
+    const to = text(candidate.to, 'to');
+    const id = text(candidate.id, 'id');
+    const nonce = text(candidate.nonce, 'nonce');
+    if (typeof candidate.type !== 'string' || !MESH_ENVELOPE_TYPES.includes(candidate.type)) {
+        throw new MeshContractError('type');
+    }
+    if (!Number.isFinite(candidate.ts) || typeof candidate.ts !== 'number' || candidate.ts <= 0) {
+        throw new MeshContractError('ts');
+    }
+    if (!isJson(candidate.payload))
+        throw new MeshContractError('payload');
+    return {
+        id,
+        from,
+        to,
+        type: candidate.type,
+        payload: candidate.payload,
+        ts: candidate.ts,
+        nonce
+    };
+}
+export function normalizeMeshNodeProfile(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new MeshContractError('profile');
+    const candidate = value;
+    const projects = Array.isArray(candidate.projects) ? candidate.projects.map((project, index) => {
+        if (!project || typeof project !== 'object' || Array.isArray(project))
+            throw new MeshContractError(`projects.${index}`);
+        const item = project;
+        const projectId = text(item.projectId, `projects.${index}.projectId`);
+        const localPath = item.localPath === undefined ? undefined : text(item.localPath, `projects.${index}.localPath`);
+        const globInclude = item.globInclude === undefined
+            ? undefined
+            : Array.isArray(item.globInclude) && item.globInclude.every((entry) => typeof entry === 'string')
+                ? [...item.globInclude]
+                : (() => { throw new MeshContractError(`projects.${index}.globInclude`); })();
+        const ports = item.ports === undefined
+            ? undefined
+            : item.ports && typeof item.ports === 'object' && !Array.isArray(item.ports)
+                && Object.entries(item.ports).every(([key, port]) => Boolean(key) && (typeof port === 'string' || typeof port === 'number'))
+                ? { ...item.ports }
+                : (() => { throw new MeshContractError(`projects.${index}.ports`); })();
+        return { projectId, localPath, globInclude, ports };
+    }) : [];
+    const roleRankValue = candidate.roleRank;
+    const roleRank = roleRankValue === undefined ? undefined : roleRankValue;
+    if (roleRank !== undefined && (typeof roleRank !== 'number' || !Number.isInteger(roleRank) || roleRank < 0)) {
+        throw new MeshContractError('roleRank');
+    }
+    return {
+        nodeId: text(candidate.nodeId, 'nodeId'),
+        principalRef: text(candidate.principalRef, 'principalRef'),
+        roleRank,
+        agentRuntime: candidate.agentRuntime === undefined ? undefined : text(candidate.agentRuntime, 'agentRuntime'),
+        projects
+    };
+}
+export function normalizeMeshQueryRequest(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new MeshContractError('query');
+    const candidate = value;
+    return {
+        queryId: text(candidate.queryId, 'queryId'),
+        from: text(candidate.from, 'from'),
+        to: text(candidate.to, 'to'),
+        question: text(candidate.question, 'question'),
+        scope: candidate.scope === undefined ? undefined : text(candidate.scope, 'scope')
+    };
+}
+export function createMeshSendReceipt(queryId) {
+    return {
+        queryId: text(queryId, 'queryId'),
+        status: 'sent',
+        receipt_kind: 'send_ack',
+        answer_status: 'unknown'
+    };
+}

package/dist/onboarding-runtime.d.ts

@@ -0,0 +1,47 @@
+import { assertSafePersistentValue, normalizeSourceInventory, type CandidateInput, type ConnectedOnboardingRun, type FirstValueInput, type ReviewAction, type SourceInventoryInput, type SourceMode, type SourceReceiptInput, type SourceStatus, type WorkflowState } from './connected-onboarding.js';
+/** Shared state and receipt vocabulary for host onboarding runtimes. */
+export declare const ONBOARDING_RUNTIME_CONTRACT_VERSION: "connected_onboarding.v1";
+export declare const ONBOARDING_WORKFLOW_STATES: readonly ["initialized", "source_ready", "candidates_ready", "promotion_reviewed", "first_value_ready", "first_value_answer_reviewed"];
+export declare const ONBOARDING_SOURCE_MODES: readonly ["mcp", "drive", "gmail", "local_folder", "single_document"];
+export declare const ONBOARDING_SOURCE_STATUSES: readonly ["ready", "waiting_for_authorization", "unavailable", "error", "unconfirmed"];
+export declare const ONBOARDING_OBSERVATION_CLASSES: readonly ["observed", "inferred"];
+export declare const FIRST_VALUE_PRESENTATION_CONTRACT: Readonly<{
+    version: "first_value_clarity.v1";
+    sections: readonly ["覚えていたこと", "つながったこと", "次にできること"];
+    humanReviewRequired: true;
+}>;
+export type { CandidateInput, ConnectedOnboardingRun, FirstValueInput, ReviewAction, SourceInventoryInput, SourceMode, SourceReceiptInput, SourceStatus, WorkflowState };
+export { assertSafePersistentValue, normalizeSourceInventory };
+export interface OnboardingPermissionSnapshot {
+    visibility?: string;
+    collectedBy?: string;
+    provider?: string;
+    connectionId?: string;
+    grantId?: string;
+    accountId?: string;
+    folderId?: string;
+    projectCode?: string;
+    roleMin?: string;
+    sensitivity?: string;
+    scope?: string;
+    scopes?: string[];
+    roles?: string[];
+    clearance?: string[];
+    authorizedAt?: string;
+    expiresAt?: string;
+}
+export interface OnboardingSourceReceiptContract {
+    sourceId: string;
+    evidencePointer: string;
+    contentHash: string;
+    permissionSnapshot: OnboardingPermissionSnapshot;
+    collectionStatus: 'collected';
+}
+export interface FirstValueRecordContract {
+    answerHash: string;
+    usedCanonicalIds: string[];
+    missingContext: string[];
+}
+export declare function normalizeOnboardingPermissionSnapshot(value: unknown): OnboardingPermissionSnapshot;
+export declare function normalizeOnboardingSourceReceipt(value: unknown): OnboardingSourceReceiptContract;
+export declare function normalizeFirstValueRecord(value: unknown): FirstValueRecordContract;