@highway1/core 0.1.47 → 0.1.48

package/src/messaging/storage.ts

@@ -0,0 +1,281 @@
+/**
+ * Message Storage - LevelDB operations for message queue
+ *
+ * Key schema:
+ *   msg:inbound:{timestamp}:{id}   → StoredMessage
+ *   msg:outbound:{timestamp}:{id}  → StoredMessage
+ *   block:{did}                    → BlocklistEntry
+ *   allow:{did}                    → AllowlistEntry
+ *   seen:{messageId}               → SeenEntry
+ *   rate:{did}                     → RateLimitState
+ *   idx:from:{did}:{timestamp}:{id} → '1'
+ */
+
+import { Level } from 'level';
+import { createLogger } from '../utils/logger.js';
+import type {
+  StoredMessage,
+  BlocklistEntry,
+  AllowlistEntry,
+  SeenEntry,
+  RateLimitState,
+  MessageFilter,
+  PaginationOptions,
+  MessagePage,
+} from './types.js';
+
+const logger = createLogger('message-storage');
+
+export class MessageStorage {
+  private db: Level<string, any>;
+  private ready = false;
+
+  constructor(dbPath: string) {
+    this.db = new Level<string, any>(dbPath, { valueEncoding: 'json' });
+  }
+
+  async open(): Promise<void> {
+    await this.db.open();
+    this.ready = true;
+    logger.info('Message storage opened');
+  }
+
+  async close(): Promise<void> {
+    if (this.ready) {
+      await this.db.close();
+      this.ready = false;
+      logger.info('Message storage closed');
+    }
+  }
+
+  // ─── Message Operations ───────────────────────────────────────────────────
+
+  async putMessage(msg: StoredMessage): Promise<void> {
+    const ts = String(msg.receivedAt ?? msg.sentAt ?? Date.now()).padStart(16, '0');
+    const key = `msg:${msg.direction}:${ts}:${msg.envelope.id}`;
+    await this.db.put(key, msg);
+
+    // Secondary index by sender
+    const idxKey = `idx:from:${msg.envelope.from}:${ts}:${msg.envelope.id}`;
+    await this.db.put(idxKey, '1');
+  }
+
+  async getMessage(id: string): Promise<StoredMessage | null> {
+    // Scan both directions since we don't know the timestamp
+    for (const direction of ['inbound', 'outbound'] as const) {
+      const prefix = `msg:${direction}:`;
+      for await (const [, value] of this.db.iterator<string, StoredMessage>({
+        gte: prefix,
+        lte: prefix + '\xff',
+        valueEncoding: 'json',
+      })) {
+        if (value.envelope.id === id) return value;
+      }
+    }
+    return null;
+  }
+
+  async updateMessage(id: string, updates: Partial<StoredMessage>): Promise<void> {
+    const msg = await this.getMessage(id);
+    if (!msg) return;
+    const ts = String(msg.receivedAt ?? msg.sentAt ?? Date.now()).padStart(16, '0');
+    const key = `msg:${msg.direction}:${ts}:${id}`;
+    await this.db.put(key, { ...msg, ...updates });
+  }
+
+  async deleteMessage(id: string): Promise<void> {
+    const msg = await this.getMessage(id);
+    if (!msg) return;
+    const ts = String(msg.receivedAt ?? msg.sentAt ?? Date.now()).padStart(16, '0');
+    const key = `msg:${msg.direction}:${ts}:${id}`;
+    const idxKey = `idx:from:${msg.envelope.from}:${ts}:${id}`;
+    await this.db.batch([
+      { type: 'del', key },
+      { type: 'del', key: idxKey },
+    ]);
+  }
+
+  async queryMessages(
+    direction: 'inbound' | 'outbound',
+    filter: MessageFilter = {},
+    pagination: PaginationOptions = {}
+  ): Promise<MessagePage> {
+    const { limit = 50, offset = 0 } = pagination;
+    const prefix = `msg:${direction}:`;
+    const results: StoredMessage[] = [];
+    let total = 0;
+    let skipped = 0;
+
+    for await (const [, value] of this.db.iterator<string, StoredMessage>({
+      gte: prefix,
+      lte: prefix + '\xff',
+      reverse: true, // newest first
+      valueEncoding: 'json',
+    })) {
+      if (!this.matchesFilter(value, filter)) continue;
+      total++;
+      if (skipped < offset) { skipped++; continue; }
+      if (results.length < limit) results.push(value);
+    }
+
+    return {
+      messages: results,
+      total,
+      hasMore: total > offset + results.length,
+    };
+  }
+
+  private matchesFilter(msg: StoredMessage, filter: MessageFilter): boolean {
+    if (filter.fromDid) {
+      const froms = Array.isArray(filter.fromDid) ? filter.fromDid : [filter.fromDid];
+      if (!froms.includes(msg.envelope.from)) return false;
+    }
+    if (filter.toDid) {
+      const tos = Array.isArray(filter.toDid) ? filter.toDid : [filter.toDid];
+      if (!tos.includes(msg.envelope.to)) return false;
+    }
+    if (filter.protocol) {
+      const protos = Array.isArray(filter.protocol) ? filter.protocol : [filter.protocol];
+      if (!protos.includes(msg.envelope.protocol)) return false;
+    }
+    if (filter.type && msg.envelope.type !== filter.type) return false;
+    if (filter.unreadOnly && msg.readAt != null) return false;
+    if (filter.status) {
+      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+      if (!statuses.includes(msg.status)) return false;
+    }
+    if (filter.maxAge) {
+      const age = Date.now() - (msg.receivedAt ?? msg.sentAt ?? 0);
+      if (age > filter.maxAge) return false;
+    }
+    if (filter.minTrustScore != null && (msg.trustScore ?? 0) < filter.minTrustScore) return false;
+    return true;
+  }
+
+  async countMessages(direction: 'inbound' | 'outbound', filter: MessageFilter = {}): Promise<number> {
+    const prefix = `msg:${direction}:`;
+    let count = 0;
+    for await (const [, value] of this.db.iterator<string, StoredMessage>({
+      gte: prefix,
+      lte: prefix + '\xff',
+      valueEncoding: 'json',
+    })) {
+      if (this.matchesFilter(value, filter)) count++;
+    }
+    return count;
+  }
+
+  // ─── Blocklist ────────────────────────────────────────────────────────────
+
+  async putBlock(entry: BlocklistEntry): Promise<void> {
+    await this.db.put(`block:${entry.did}`, entry);
+  }
+
+  async getBlock(did: string): Promise<BlocklistEntry | null> {
+    try {
+      return await this.db.get(`block:${did}`);
+    } catch {
+      return null;
+    }
+  }
+
+  async deleteBlock(did: string): Promise<void> {
+    try { await this.db.del(`block:${did}`); } catch { /* not found */ }
+  }
+
+  async listBlocked(): Promise<BlocklistEntry[]> {
+    const results: BlocklistEntry[] = [];
+    for await (const [, value] of this.db.iterator<string, BlocklistEntry>({
+      gte: 'block:',
+      lte: 'block:\xff',
+      valueEncoding: 'json',
+    })) {
+      results.push(value);
+    }
+    return results;
+  }
+
+  // ─── Allowlist ────────────────────────────────────────────────────────────
+
+  async putAllow(entry: AllowlistEntry): Promise<void> {
+    await this.db.put(`allow:${entry.did}`, entry);
+  }
+
+  async getAllow(did: string): Promise<AllowlistEntry | null> {
+    try {
+      return await this.db.get(`allow:${did}`);
+    } catch {
+      return null;
+    }
+  }
+
+  async deleteAllow(did: string): Promise<void> {
+    try { await this.db.del(`allow:${did}`); } catch { /* not found */ }
+  }
+
+  async listAllowed(): Promise<AllowlistEntry[]> {
+    const results: AllowlistEntry[] = [];
+    for await (const [, value] of this.db.iterator<string, AllowlistEntry>({
+      gte: 'allow:',
+      lte: 'allow:\xff',
+      valueEncoding: 'json',
+    })) {
+      results.push(value);
+    }
+    return results;
+  }
+
+  // ─── Seen Cache ───────────────────────────────────────────────────────────
+
+  async putSeen(entry: SeenEntry): Promise<void> {
+    await this.db.put(`seen:${entry.messageId}`, entry);
+  }
+
+  async getSeen(messageId: string): Promise<SeenEntry | null> {
+    try {
+      return await this.db.get(`seen:${messageId}`);
+    } catch {
+      return null;
+    }
+  }
+
+  async cleanupSeen(maxAgeMs: number): Promise<void> {
+    const cutoff = Date.now() - maxAgeMs;
+    const toDelete: string[] = [];
+    for await (const [key, value] of this.db.iterator<string, SeenEntry>({
+      gte: 'seen:',
+      lte: 'seen:\xff',
+      valueEncoding: 'json',
+    })) {
+      if (value.seenAt < cutoff) toDelete.push(key);
+    }
+    await this.db.batch(toDelete.map((key) => ({ type: 'del' as const, key })));
+  }
+
+  // ─── Rate Limit State ─────────────────────────────────────────────────────
+
+  async putRateLimit(state: RateLimitState): Promise<void> {
+    await this.db.put(`rate:${state.did}`, state);
+  }
+
+  async getRateLimit(did: string): Promise<RateLimitState | null> {
+    try {
+      return await this.db.get(`rate:${did}`);
+    } catch {
+      return null;
+    }
+  }
+
+  async cleanupRateLimits(maxAgeMs: number): Promise<void> {
+    const cutoff = Date.now() - maxAgeMs;
+    const toDelete: string[] = [];
+    for await (const [key, value] of this.db.iterator<string, RateLimitState>({
+      gte: 'rate:',
+      lte: 'rate:\xff',
+      valueEncoding: 'json',
+    })) {
+      if (value.lastRefill < cutoff) toDelete.push(key);
+    }
+    await this.db.batch(toDelete.map((key) => ({ type: 'del' as const, key })));
+  }
+}

package/src/messaging/types.ts

@@ -0,0 +1,149 @@
+/**
+ * Message Queue Types
+ *
+ * Types for message queue, storage, and filtering operations.
+ */
+
+import type { MessageEnvelope } from './envelope.js';
+
+/**
+ * Message direction
+ */
+export type MessageDirection = 'inbound' | 'outbound';
+
+/**
+ * Message status
+ */
+export type MessageStatus = 'pending' | 'delivered' | 'failed' | 'archived';
+
+/**
+ * Stored message with metadata
+ */
+export interface StoredMessage {
+  envelope: MessageEnvelope;
+  direction: MessageDirection;
+  status: MessageStatus;
+  receivedAt?: number;
+  sentAt?: number;
+  readAt?: number;
+  trustScore?: number;
+  error?: string;
+}
+
+/**
+ * Message filter for queries
+ */
+export interface MessageFilter {
+  fromDid?: string | string[];
+  toDid?: string | string[];
+  protocol?: string | string[];
+  minTrustScore?: number;
+  maxAge?: number; // milliseconds
+  type?: 'request' | 'response' | 'notification';
+  unreadOnly?: boolean;
+  status?: MessageStatus | MessageStatus[];
+}
+
+/**
+ * Pagination options
+ */
+export interface PaginationOptions {
+  limit?: number;
+  offset?: number;
+  startKey?: string; // For cursor-based pagination
+}
+
+/**
+ * Paginated message results
+ */
+export interface MessagePage {
+  messages: StoredMessage[];
+  total: number;
+  hasMore: boolean;
+  nextKey?: string;
+}
+
+/**
+ * Blocklist entry
+ */
+export interface BlocklistEntry {
+  did: string;
+  reason: string;
+  blockedAt: number;
+  blockedBy: string; // Local agent DID
+}
+
+/**
+ * Allowlist entry
+ */
+export interface AllowlistEntry {
+  did: string;
+  addedAt: number;
+  note?: string;
+}
+
+/**
+ * Seen cache entry (for deduplication)
+ */
+export interface SeenEntry {
+  messageId: string;
+  seenAt: number;
+  fromDid: string;
+}
+
+/**
+ * Rate limit state
+ */
+export interface RateLimitState {
+  did: string;
+  tokens: number;
+  lastRefill: number;
+  totalRequests: number;
+  firstSeen: number;
+}
+
+/**
+ * Defense check result
+ */
+export interface DefenseResult {
+  allowed: boolean;
+  reason?: 'blocked' | 'duplicate' | 'trust_too_low' | 'rate_limited' | 'invalid';
+  trustScore?: number;
+  remainingTokens?: number;
+  resetTime?: number;
+}
+
+/**
+ * Rate limit result
+ */
+export interface RateLimitResult {
+  allowed: boolean;
+  remaining: number;
+  resetTime: number;
+  limit: number;
+}
+
+/**
+ * Queue statistics
+ */
+export interface QueueStats {
+  inboxTotal: number;
+  inboxUnread: number;
+  outboxPending: number;
+  outboxFailed: number;
+  blockedAgents: number;
+  allowedAgents: number;
+  rateLimitedAgents: number;
+}
+
+/**
+ * Subscription callback
+ */
+export type MessageCallback = (message: StoredMessage) => void | Promise<void>;
+
+/**
+ * Subscription filter
+ */
+export interface SubscriptionFilter extends MessageFilter {
+  webhookUrl?: string;
+}

package/src/transport/node.ts

@@ -1,5 +1,6 @@
 import { createLibp2p, Libp2p } from 'libp2p';
 import { tcp } from '@libp2p/tcp';
+import { webSockets } from '@libp2p/websockets';
 import { noise } from '@chainsafe/libp2p-noise';
 import { mplex } from '@libp2p/mplex';
 import { kadDHT, passthroughMapper } from '@libp2p/kad-dht';
@@ -48,7 +49,7 @@ export async function createNode(
 ): Promise<ClawiverseNode> {
   try {
     const {
-      listenAddresses = ['/ip4/0.0.0.0/tcp/0'],
+      listenAddresses = ['/ip4/0.0.0.0/tcp/0', '/ip4/0.0.0.0/tcp/0/ws'], // CVP-0010 §5: Add WebSocket listener
       bootstrapPeers = [],
       enableDHT = true,
       enableRelay = false,
@@ -69,6 +70,7 @@ export async function createNode(
       ...(privateKey ? { privateKey } : {}),
       transports: [
         tcp(),
+        webSockets(),           // CVP-0010 §5: WebSocket for firewall traversal
         circuitRelayTransport(),
       ],
       connectionEncrypters: [noise()],

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Clawiverse Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.