@mebular/fleet 0.0.0-stage → 0.1.0

package/src/store/daemon-store.ts

@@ -0,0 +1,144 @@
+// W2 B1：fleet 客户端化——任务事件存进**守护的本机 app 接口**（loopback HTTP + token）。
+//
+// daemon 模式（默认于统一上车）：node/worker 不再监听 libp2p、不托管 join——网络/身份/信任归守护；
+// fleet 只保留任务语义/agents/配额/执行器/工具体系。embedded 模式仅供测试/CI。
+
+import http from 'node:http';
+import https from 'node:https';
+import { readFileSync } from 'node:fs';
+import type { TaskEvent } from '../protocol/events.js';
+import { validateTaskEvent } from '../protocol/events.js';
+import { dedupeEvents } from '../model.js';
+import type { TaskEventStore } from './file-store.js';
+
+export interface DaemonStoreOptions {
+  /** 守护 app 端点，如 http://127.0.0.1:7331 */
+  endpoint: string;
+  /** 任务分区（默认 tasks） */
+  namespace?: string;
+  /** 事件节点类型（默认 task_event） */
+  type?: string;
+  /** bearer token（内联）；与 tokenFile 二选一 */
+  token?: string;
+  /** token 文件（JSON 数组或 {tokens:[…]}? 这里取纯文本/JSON 点路径，默认整文件文本） */
+  tokenFile?: string;
+  timeoutMs?: number;
+}
+
+interface DaemonReply {
+  ok: boolean;
+  error?: string;
+  count?: number;
+  nodes?: Array<{ id: string; type: string; namespace: string; content: unknown }>;
+  node?: { id: string; type: string; namespace: string };
+}
+
+function readToken(options: DaemonStoreOptions): string | undefined {
+  if (options.token !== undefined && options.token.length > 0) return options.token;
+  if (options.tokenFile !== undefined) {
+    try {
+      const raw = readFileSync(options.tokenFile, 'utf-8').trim();
+      if (raw.startsWith('{')) {
+        const parsed = JSON.parse(raw) as { token?: unknown };
+        // 仅接受 `{ token }` 形态；`tokens.json`（多令牌）不猜，返回 undefined（调用方应内联 token）
+        return typeof parsed.token === 'string' && parsed.token.length > 0 ? parsed.token : undefined;
+      }
+      return raw.length > 0 ? raw : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+  return undefined;
+}
+
+function requestJson<T>(url: string, method: string, token: string | undefined, body: unknown, timeoutMs: number): Promise<{ status: number; json: T }> {
+  return new Promise((resolve, reject) => {
+    const payload = body === undefined ? undefined : JSON.stringify(body);
+    const u = new URL(url);
+    const transport = u.protocol === 'https:' ? https : http;
+    const headers: Record<string, string> = {};
+    if (payload !== undefined) {
+      headers['content-type'] = 'application/json';
+      headers['content-length'] = String(Buffer.byteLength(payload));
+    }
+    if (token !== undefined) headers.authorization = `Bearer ${token}`;
+    const req = transport.request(u, { method, headers }, (res) => {
+      let data = '';
+      res.on('data', (c: Buffer) => (data += c.toString('utf-8')));
+      res.on('end', () => {
+        try {
+          resolve({ status: res.statusCode ?? 0, json: JSON.parse(data) as T });
+        } catch (error) {
+          reject(new Error(`守护响应无法解析：${(error as Error).message}`));
+        }
+      });
+    });
+    req.setTimeout(timeoutMs, () => req.destroy(new Error('守护请求超时')));
+    req.on('error', reject);
+    if (payload !== undefined) req.write(payload);
+    req.end();
+  });
+}
+
+/**
+ * 走守护 app 接口的任务事件存储。**无本地 Mebular、无 libp2p、无身份处理**。
+ * 幂等由 `eventId` 去重保证（与 `MebularTaskEventStore` 同一语义）。
+ */
+export class DaemonTaskEventStore implements TaskEventStore {
+  private readonly endpoint: string;
+  private readonly namespace: string;
+  private readonly type: string;
+  private readonly token: string | undefined;
+  private readonly timeoutMs: number;
+
+  constructor(options: DaemonStoreOptions) {
+    if (typeof options.endpoint !== 'string' || options.endpoint.length === 0) {
+      throw new Error('DaemonTaskEventStore 需要 endpoint');
+    }
+    this.endpoint = options.endpoint.replace(/\/+$/, '');
+    this.namespace = options.namespace ?? 'tasks';
+    this.type = options.type ?? 'task_event';
+    this.token = readToken(options);
+    this.timeoutMs = options.timeoutMs ?? 15_000;
+  }
+
+  private async list(): Promise<DaemonReply> {
+    const url = `${this.endpoint}/app/nodes?namespace=${encodeURIComponent(this.namespace)}&type=${encodeURIComponent(this.type)}`;
+    const { status, json } = await requestJson<DaemonReply>(url, 'GET', this.token, undefined, this.timeoutMs);
+    if (status !== 200 || json.ok !== true) throw new Error(`守护 listNodes 失败（HTTP ${status}）：${json.error ?? '未知'}`);
+    return json;
+  }
+
+  async all(): Promise<TaskEvent[]> {
+    const reply = await this.list();
+    const valid: TaskEvent[] = [];
+    for (const node of reply.nodes ?? []) {
+      if (typeof node.content !== 'object' || node.content === null) continue;
+      if (!validateTaskEvent(node.content).ok) continue;
+      valid.push(node.content as unknown as TaskEvent);
+    }
+    return dedupeEvents(valid);
+  }
+
+  async append(event: TaskEvent): Promise<boolean> {
+    const existing = await this.all();
+    if (existing.some((e) => e.eventId === event.eventId)) return false;
+    const { status, json } = await requestJson<DaemonReply>(
+      `${this.endpoint}/app/nodes`,
+      'POST',
+      this.token,
+      { type: this.type, namespace: this.namespace, content: event },
+      this.timeoutMs,
+    );
+    if (status !== 200 || json.ok !== true) throw new Error(`守护 createNode 失败（HTTP ${status}）：${json.error ?? '未知'}`);
+    return true;
+  }
+
+  async byTask(taskId: string): Promise<TaskEvent[]> {
+    return (await this.all()).filter((e) => e.taskId === taskId);
+  }
+
+  async close(): Promise<void> {
+    // 连接按需创建；无持久资源。
+  }
+}

package/src/store/file-store.ts

@@ -0,0 +1,75 @@
+// 任务事件本地存储（M2）：JSONL 追加 + `eventId` 去重（幂等落库）。
+//
+// 每个进程用自己的存储路径（验收要求：两进程 storage 独立）。重启后从文件恢复，
+// 支撑「重启韧性/不丢不重」。
+
+import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import type { TaskEvent } from '../protocol/events.js';
+
+export interface TaskEventStore {
+  /** 追加事件；`eventId` 已存在则返回 `false`（幂等，不重复落库）。 */
+  append(event: TaskEvent): Promise<boolean>;
+  all(): Promise<TaskEvent[]>;
+  byTask(taskId: string): Promise<TaskEvent[]>;
+  close(): Promise<void>;
+}
+
+export class FileTaskEventStore implements TaskEventStore {
+  private readonly path: string;
+  private readonly events: TaskEvent[] = [];
+  private readonly seen = new Set<string>();
+
+  private constructor(path: string) {
+    this.path = path;
+  }
+
+  /** 打开（或创建）存储并恢复既有事件。 */
+  static async open(path: string): Promise<FileTaskEventStore> {
+    const store = new FileTaskEventStore(path);
+    await mkdir(dirname(path), { recursive: true });
+    let raw = '';
+    try {
+      raw = await readFile(path, 'utf-8');
+    } catch {
+      raw = '';
+    }
+    const lines = raw.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i]!.trim();
+      if (line === '') continue;
+      try {
+        store.push(JSON.parse(line) as TaskEvent);
+      } catch {
+        // 末尾半行（崩溃）跳过；中间行损坏说明文件被破坏，跳过该行但仍继续（不静默重置）。
+        continue;
+      }
+    }
+    return store;
+  }
+
+  private push(event: TaskEvent): void {
+    if (this.seen.has(event.eventId)) return;
+    this.seen.add(event.eventId);
+    this.events.push(event);
+  }
+
+  async append(event: TaskEvent): Promise<boolean> {
+    if (this.seen.has(event.eventId)) return false;
+    await appendFile(this.path, `${JSON.stringify(event)}\n`, 'utf-8');
+    this.push(event);
+    return true;
+  }
+
+  async all(): Promise<TaskEvent[]> {
+    return [...this.events];
+  }
+
+  async byTask(taskId: string): Promise<TaskEvent[]> {
+    return this.events.filter((e) => e.taskId === taskId);
+  }
+
+  async close(): Promise<void> {
+    // 无长连接；追加即时落盘。
+  }
+}

package/src/store/mebular-store.ts

@@ -0,0 +1,66 @@
+// 任务事件存储（M3）：以 `@mebular/core` 的**图示记忆**为载体，任务事件即一类记忆节点。
+//
+// 于是「任务经记忆同步传递」——由 core 的同步（写入即推 + anti-entropy + 变更订阅）负责复制，
+// fleet 只消费 `Mebular.graph` 的**公共 API**（createNode/listNodes），不碰 core 内部。
+
+import type { Mebular } from '@mebular/core';
+import type { TaskEvent } from '../protocol/events.js';
+import { validateTaskEvent } from '../protocol/events.js';
+import { dedupeEvents } from '../model.js';
+import type { TaskEventStore } from './file-store.js';
+
+export interface MebularTaskEventStoreOptions {
+  /** 任务分区（默认 `tasks`） */
+  namespace?: string;
+  /** 任务事件节点类型（默认 `task_event`） */
+  type?: string;
+}
+
+/** 用 Mebular 图示记忆承载任务事件；幂等由 `eventId` 去重保证。 */
+export class MebularTaskEventStore implements TaskEventStore {
+  private readonly mebular: Mebular;
+  private readonly namespace: string;
+  private readonly type: string;
+
+  constructor(mebular: Mebular, options: MebularTaskEventStoreOptions = {}) {
+    this.mebular = mebular;
+    this.namespace = options.namespace ?? 'tasks';
+    this.type = options.type ?? 'task_event';
+  }
+
+  private async events(): Promise<TaskEvent[]> {
+    // NodeFilter 无 namespace 字段：按 type 取回后在本层过滤 namespace。
+    const nodes = await this.mebular.graph.listNodes({ type: this.type });
+    const valid: TaskEvent[] = [];
+    for (const node of nodes) {
+      if (node.namespace !== this.namespace) continue;
+      const candidate = node.content;
+      if (typeof candidate !== 'object' || candidate === null) continue;
+      if (!validateTaskEvent(candidate).ok) continue; // 忽略非任务事件节点
+      valid.push(candidate as unknown as TaskEvent);
+    }
+    // 与 reducer 同一去重语义（同 id 冲突的确定性裁决），避免 store/reducer 漂移
+    return dedupeEvents(valid);
+  }
+
+  async append(event: TaskEvent): Promise<boolean> {
+    const existing = await this.events();
+    if (existing.some((e) => e.eventId === event.eventId)) return false;
+    await this.mebular.graph.createNode(this.type, event as unknown as Record<string, unknown>, [], {
+      namespace: this.namespace,
+    });
+    return true;
+  }
+
+  async all(): Promise<TaskEvent[]> {
+    return this.events();
+  }
+
+  async byTask(taskId: string): Promise<TaskEvent[]> {
+    return (await this.events()).filter((e) => e.taskId === taskId);
+  }
+
+  async close(): Promise<void> {
+    // 存储生命周期由 Mebular 实例管理。
+  }
+}

package/src/store/message-store.ts

@@ -0,0 +1,62 @@
+// 通用「消息」存储（1d）：协商/闲聊消息以**图节点**承载，落在既有 **已授权** 的 tasks 分区内，
+// 用**不同节点类型**区分（`negotiation_message` / `chatter_message`），从而随 core 记忆同步传递
+// ——无需新增分区/授权/同步原语。幂等键 = `messageId`（重复 append 返回 false）。
+
+import type { Mebular } from '@mebular/core';
+
+export interface MebularMessageStoreOptions<T> {
+  /** 节点类型（必填，用于与任务事件区分） */
+  type: string;
+  /** 分区（默认 `tasks`：复用既有已授权分区） */
+  namespace?: string;
+  /** 校验（形状非法 → 忽略） */
+  validate: (input: unknown) => { ok: boolean };
+  /** 幂等键 */
+  idOf: (message: T) => string;
+}
+
+/** 以 Mebular 图示记忆承载的幂等消息存储（协商/闲聊）。 */
+export class MebularMessageStore<T> {
+  private readonly mebular: Mebular;
+  private readonly namespace: string;
+  private readonly type: string;
+  private readonly validate: (input: unknown) => { ok: boolean };
+  private readonly idOf: (message: T) => string;
+
+  constructor(mebular: Mebular, options: MebularMessageStoreOptions<T>) {
+    this.mebular = mebular;
+    this.namespace = options.namespace ?? 'tasks';
+    this.type = options.type;
+    this.validate = options.validate;
+    this.idOf = options.idOf;
+  }
+
+  async all(): Promise<T[]> {
+    const nodes = await this.mebular.graph.listNodes({ type: this.type });
+    const valid: T[] = [];
+    for (const node of nodes) {
+      if (node.namespace !== this.namespace) continue;
+      const candidate = node.content;
+      if (typeof candidate !== 'object' || candidate === null) continue;
+      if (!this.validate(candidate).ok) continue;
+      valid.push(candidate as unknown as T);
+    }
+    // 幂等去重（同 messageId 确定取首见；去重后按 id 字典序 → 顺序无关）
+    const byId = new Map<string, T>();
+    for (const message of valid) if (!byId.has(this.idOf(message))) byId.set(this.idOf(message), message);
+    return [...byId.values()].sort((a, b) => (this.idOf(a) < this.idOf(b) ? -1 : this.idOf(a) > this.idOf(b) ? 1 : 0));
+  }
+
+  async append(message: T): Promise<boolean> {
+    const id = this.idOf(message);
+    if ((await this.all()).some((m) => this.idOf(m) === id)) return false;
+    await this.mebular.graph.createNode(this.type, message as unknown as Record<string, unknown>, [], {
+      namespace: this.namespace,
+    });
+    return true;
+  }
+
+  async close(): Promise<void> {
+    // 生命周期由 Mebular 管理
+  }
+}