@sesamespace/hivemind 0.1.0 → 0.2.0

package/dist/chunk-NVJ424TB.js

@@ -0,0 +1,731 @@
+import {
+  DEFAULT_HEALTH_INTERVAL_MS,
+  DEFAULT_SYNC_INTERVAL_MS,
+  HEALTH_TIMEOUT_MS,
+  PRIMARY_ROUTES,
+  WORKER_ROUTES
+} from "./chunk-2I2O6X5D.js";
+
+// packages/runtime/src/fleet/primary-client.ts
+var PrimaryClient = class {
+  workers = /* @__PURE__ */ new Map();
+  healthTimer = null;
+  nextId = 1;
+  onSyncPullCallback = null;
+  /** All registered workers. */
+  getWorkers() {
+    return Array.from(this.workers.values());
+  }
+  /** Get a single worker by ID. */
+  getWorker(workerId) {
+    return this.workers.get(workerId);
+  }
+  /** Find which worker owns a context, if any. */
+  findWorkerForContext(contextName) {
+    for (const w of this.workers.values()) {
+      if (w.assigned_contexts.includes(contextName)) return w;
+    }
+    return void 0;
+  }
+  // --- Registration (called when Worker POSTs to Primary) ---
+  handleRegistration(req) {
+    const id = `worker-${this.nextId++}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const info = {
+      id,
+      url: req.url,
+      capabilities: req.capabilities,
+      assigned_contexts: [],
+      registered_at: now,
+      last_heartbeat: now
+    };
+    this.workers.set(id, info);
+    return { worker_id: id, registered_at: now };
+  }
+  /** Remove a worker from the registry. */
+  deregister(workerId) {
+    return this.workers.delete(workerId);
+  }
+  // --- Health Checking ---
+  /** Poll a single worker's health endpoint. */
+  async checkHealth(workerId) {
+    const worker = this.workers.get(workerId);
+    if (!worker) return null;
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), HEALTH_TIMEOUT_MS);
+      const resp = await fetch(`${worker.url}${WORKER_ROUTES.health}`, {
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      if (!resp.ok) {
+        this.markUnreachable(workerId);
+        return null;
+      }
+      const health = await resp.json();
+      worker.last_heartbeat = (/* @__PURE__ */ new Date()).toISOString();
+      return health;
+    } catch {
+      this.markUnreachable(workerId);
+      return null;
+    }
+  }
+  /** Poll all workers and return their statuses. */
+  async checkAllHealth() {
+    const results = /* @__PURE__ */ new Map();
+    const checks = Array.from(this.workers.keys()).map(async (id) => {
+      const health = await this.checkHealth(id);
+      results.set(id, health?.status ?? "unreachable");
+    });
+    await Promise.all(checks);
+    return results;
+  }
+  /** Start periodic health polling. */
+  startHealthPolling(intervalMs = DEFAULT_HEALTH_INTERVAL_MS) {
+    this.stopHealthPolling();
+    this.healthTimer = setInterval(() => {
+      this.checkAllHealth().catch(() => {
+      });
+    }, intervalMs);
+  }
+  /** Stop periodic health polling. */
+  stopHealthPolling() {
+    if (this.healthTimer) {
+      clearInterval(this.healthTimer);
+      this.healthTimer = null;
+    }
+  }
+  // --- Context Assignment ---
+  /** Assign a context to a worker. */
+  async assignContext(workerId, contextName, contextDescription = "") {
+    const worker = this.workers.get(workerId);
+    if (!worker) {
+      return { context_name: contextName, accepted: false, reason: "Worker not found" };
+    }
+    if (worker.assigned_contexts.length >= worker.capabilities.max_contexts) {
+      return { context_name: contextName, accepted: false, reason: "Worker at capacity" };
+    }
+    const body = {
+      context_name: contextName,
+      context_description: contextDescription
+    };
+    try {
+      const resp = await fetch(`${worker.url}${WORKER_ROUTES.assign}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!resp.ok) {
+        const text = await resp.text();
+        return { context_name: contextName, accepted: false, reason: `Worker rejected: ${text}` };
+      }
+      const result = await resp.json();
+      if (result.accepted) {
+        worker.assigned_contexts.push(contextName);
+      }
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { context_name: contextName, accepted: false, reason: `Request failed: ${msg}` };
+    }
+  }
+  /** Unassign a context from a worker. */
+  async unassignContext(workerId, contextName) {
+    const worker = this.workers.get(workerId);
+    if (!worker) return false;
+    try {
+      const resp = await fetch(`${worker.url}${WORKER_ROUTES.unassign(contextName)}`, {
+        method: "DELETE"
+      });
+      if (resp.ok) {
+        worker.assigned_contexts = worker.assigned_contexts.filter((c) => c !== contextName);
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  // --- Status Collection ---
+  /** Handle an incoming status report from a Worker. */
+  handleStatusReport(workerId, report) {
+    const worker = this.workers.get(workerId);
+    if (!worker) return null;
+    worker.last_heartbeat = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      worker_id: workerId,
+      activity: report.activity,
+      current_context: report.current_context,
+      current_task: report.current_task,
+      error: report.error,
+      reported_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  // --- Memory Sync ---
+  /** Register a handler for incoming sync pull requests from Workers. */
+  onSyncPull(cb) {
+    this.onSyncPullCallback = cb;
+  }
+  /** Handle an incoming sync pull (Worker sends L3 knowledge to Primary). */
+  async handleSyncPull(req) {
+    if (!this.onSyncPullCallback) {
+      return { accepted: 0, rejected: req.entries.length };
+    }
+    return this.onSyncPullCallback(req);
+  }
+  /** Push Global context updates to a specific worker. */
+  async pushSyncToWorker(workerId, payload) {
+    const worker = this.workers.get(workerId);
+    if (!worker) return null;
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), HEALTH_TIMEOUT_MS);
+      const resp = await fetch(`${worker.url}${WORKER_ROUTES.syncPush}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      if (!resp.ok) return null;
+      return await resp.json();
+    } catch {
+      return null;
+    }
+  }
+  /** Push Global context updates to all registered workers. */
+  async pushSyncToAll(payload) {
+    const results = /* @__PURE__ */ new Map();
+    const pushes = Array.from(this.workers.keys()).map(async (id) => {
+      const result = await this.pushSyncToWorker(id, payload);
+      results.set(id, result);
+    });
+    await Promise.all(pushes);
+    return results;
+  }
+  // --- Internal ---
+  markUnreachable(workerId) {
+  }
+};
+
+// packages/runtime/src/fleet/fleet-manager.ts
+var FleetManager = class {
+  primary;
+  latestHealth = /* @__PURE__ */ new Map();
+  latestStatus = /* @__PURE__ */ new Map();
+  knownContexts = /* @__PURE__ */ new Set();
+  constructor(primary) {
+    this.primary = primary ?? new PrimaryClient();
+  }
+  getPrimary() {
+    return this.primary;
+  }
+  // --- Worker Provisioning ---
+  /**
+   * Register a new worker by URL. Probes the worker's health endpoint
+   * to discover capabilities, then registers it with the Primary.
+   */
+  async addWorker(url) {
+    const baseUrl = url.replace(/\/+$/, "");
+    const capabilities = await this.probeWorker(baseUrl);
+    const reg = this.primary.handleRegistration({ url: baseUrl, capabilities });
+    const worker = this.primary.getWorker(reg.worker_id);
+    if (!worker) {
+      throw new Error("Worker registered but not found in registry");
+    }
+    return worker;
+  }
+  /** Remove a worker from the fleet, unassigning its contexts first. */
+  async removeWorker(workerId) {
+    const worker = this.primary.getWorker(workerId);
+    if (!worker) return false;
+    for (const ctx of [...worker.assigned_contexts]) {
+      await this.primary.unassignContext(workerId, ctx);
+    }
+    return this.primary.deregister(workerId);
+  }
+  // --- Context Assignment ---
+  /** Assign a context to a specific worker. */
+  async assignContext(workerId, contextName, description = "") {
+    const result = await this.primary.assignContext(workerId, contextName, description);
+    if (result.accepted) {
+      this.knownContexts.add(contextName);
+    }
+    return result;
+  }
+  /** Migrate a context from one worker to another. */
+  async migrateContext(contextName, toWorkerId) {
+    const fromWorker = this.primary.findWorkerForContext(contextName);
+    if (!fromWorker) {
+      const resp = await this.primary.assignContext(toWorkerId, contextName);
+      return {
+        context_name: contextName,
+        from_worker: "(none)",
+        to_worker: toWorkerId,
+        success: resp.accepted,
+        reason: resp.accepted ? void 0 : resp.reason
+      };
+    }
+    if (fromWorker.id === toWorkerId) {
+      return {
+        context_name: contextName,
+        from_worker: fromWorker.id,
+        to_worker: toWorkerId,
+        success: false,
+        reason: "Context already assigned to this worker"
+      };
+    }
+    const assignResult = await this.primary.assignContext(toWorkerId, contextName);
+    if (!assignResult.accepted) {
+      return {
+        context_name: contextName,
+        from_worker: fromWorker.id,
+        to_worker: toWorkerId,
+        success: false,
+        reason: assignResult.reason ?? "Target worker rejected assignment"
+      };
+    }
+    await this.primary.unassignContext(fromWorker.id, contextName);
+    return {
+      context_name: contextName,
+      from_worker: fromWorker.id,
+      to_worker: toWorkerId,
+      success: true
+    };
+  }
+  // --- Status & Health ---
+  /** Refresh health for all workers. */
+  async refreshHealth() {
+    const workers = this.primary.getWorkers();
+    const checks = workers.map(async (w) => {
+      const health = await this.primary.checkHealth(w.id);
+      if (health) {
+        this.latestHealth.set(w.id, health);
+      } else {
+        this.latestHealth.set(w.id, {
+          worker_id: w.id,
+          status: "unreachable",
+          uptime_seconds: 0,
+          assigned_contexts: w.assigned_contexts,
+          active_context: null,
+          memory_daemon_ok: false,
+          ollama_ok: false
+        });
+      }
+    });
+    await Promise.all(checks);
+  }
+  /** Record a status report (called when worker POSTs status to Primary). */
+  recordStatus(workerId, status) {
+    this.latestStatus.set(workerId, status);
+  }
+  /** Get the full fleet dashboard. */
+  async getDashboard() {
+    await this.refreshHealth();
+    const workers = this.primary.getWorkers();
+    let healthy = 0;
+    let degraded = 0;
+    let unreachable = 0;
+    let totalContexts = 0;
+    const workerSummaries = workers.map((w) => {
+      const health = this.latestHealth.get(w.id);
+      const status = this.latestStatus.get(w.id);
+      const healthStatus = health?.status ?? "unreachable";
+      if (healthStatus === "healthy") healthy++;
+      else if (healthStatus === "degraded") degraded++;
+      else unreachable++;
+      totalContexts += w.assigned_contexts.length;
+      return {
+        id: w.id,
+        url: w.url,
+        health: healthStatus,
+        contexts: w.assigned_contexts,
+        current_task: status?.current_task ?? null,
+        activity: status?.activity ?? "idle",
+        uptime_seconds: health?.uptime_seconds ?? null,
+        capabilities: w.capabilities,
+        last_heartbeat: w.last_heartbeat
+      };
+    });
+    const assignedContexts = new Set(workers.flatMap((w) => w.assigned_contexts));
+    const unassigned = [...this.knownContexts].filter((c) => !assignedContexts.has(c));
+    return {
+      total_workers: workers.length,
+      healthy,
+      degraded,
+      unreachable,
+      total_contexts: totalContexts,
+      workers: workerSummaries,
+      unassigned_contexts: unassigned,
+      generated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /** Get a quick status summary without refreshing health. */
+  getStatusSnapshot() {
+    const workers = this.primary.getWorkers();
+    let healthy = 0;
+    let degraded = 0;
+    let unreachable = 0;
+    let totalContexts = 0;
+    const workerSummaries = workers.map((w) => {
+      const health = this.latestHealth.get(w.id);
+      const status = this.latestStatus.get(w.id);
+      const healthStatus = health?.status ?? "unreachable";
+      if (healthStatus === "healthy") healthy++;
+      else if (healthStatus === "degraded") degraded++;
+      else unreachable++;
+      totalContexts += w.assigned_contexts.length;
+      return {
+        id: w.id,
+        url: w.url,
+        health: healthStatus,
+        contexts: w.assigned_contexts,
+        current_task: status?.current_task ?? null,
+        activity: status?.activity ?? "idle",
+        uptime_seconds: health?.uptime_seconds ?? null,
+        capabilities: w.capabilities,
+        last_heartbeat: w.last_heartbeat
+      };
+    });
+    const assignedContexts = new Set(workers.flatMap((w) => w.assigned_contexts));
+    const unassigned = [...this.knownContexts].filter((c) => !assignedContexts.has(c));
+    return {
+      total_workers: workers.length,
+      healthy,
+      degraded,
+      unreachable,
+      total_contexts: totalContexts,
+      workers: workerSummaries,
+      unassigned_contexts: unassigned,
+      generated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  // --- Worker Discovery ---
+  /**
+   * Scan a list of candidate URLs for workers. Returns the URLs
+   * that responded to a health probe. Useful for auto-detecting
+   * workers on a local network.
+   */
+  async discoverWorkers(candidateUrls) {
+    const found = [];
+    const probes = candidateUrls.map(async (url) => {
+      const baseUrl = url.replace(/\/+$/, "");
+      try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), HEALTH_TIMEOUT_MS);
+        const resp = await fetch(`${baseUrl}${WORKER_ROUTES.health}`, {
+          signal: controller.signal
+        });
+        clearTimeout(timeout);
+        if (resp.ok) {
+          found.push(baseUrl);
+        }
+      } catch {
+      }
+    });
+    await Promise.all(probes);
+    return found;
+  }
+  /**
+   * Scan a subnet-style range for workers. Generates URLs for
+   * a base IP with ports and probes them.
+   * Example: scanSubnet("192.168.1", [10, 11, 12], 3100)
+   */
+  async scanSubnet(baseIp, hostIds, port) {
+    const urls = hostIds.map((id) => `http://${baseIp}.${id}:${port}`);
+    return this.discoverWorkers(urls);
+  }
+  /** Track a context name so it appears in unassigned lists. */
+  registerContext(contextName) {
+    this.knownContexts.add(contextName);
+  }
+  /** Start health polling (delegates to PrimaryClient). */
+  startHealthPolling(intervalMs) {
+    this.primary.startHealthPolling(intervalMs);
+  }
+  /** Stop health polling. */
+  stopHealthPolling() {
+    this.primary.stopHealthPolling();
+  }
+  // --- Internal ---
+  async probeWorker(baseUrl) {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), HEALTH_TIMEOUT_MS);
+      const resp = await fetch(`${baseUrl}${WORKER_ROUTES.health}`, {
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      if (resp.ok) {
+        const health = await resp.json();
+        return {
+          max_contexts: health.assigned_contexts.length + 4,
+          // assume capacity
+          has_ollama: health.ollama_ok,
+          has_memory_daemon: health.memory_daemon_ok,
+          available_models: []
+        };
+      }
+    } catch {
+    }
+    return {
+      max_contexts: 4,
+      has_ollama: false,
+      has_memory_daemon: false,
+      available_models: []
+    };
+  }
+};
+
+// packages/runtime/src/fleet/memory-sync.ts
+function l3ToSync(entry) {
+  return {
+    id: entry.id,
+    source_episode_id: entry.source_episode_id,
+    context_name: entry.context_name,
+    content: entry.content,
+    promoted_at: entry.promoted_at,
+    access_count: entry.access_count,
+    connection_density: entry.connection_density,
+    updated_at: entry.promoted_at
+  };
+}
+function episodeToSync(ep) {
+  return {
+    id: ep.id,
+    timestamp: ep.timestamp,
+    context_name: ep.context_name,
+    role: ep.role,
+    content: ep.content
+  };
+}
+var WorkerMemorySync = class {
+  workerId;
+  primaryUrl;
+  memory;
+  syncTimer = null;
+  syncIntervalMs;
+  knownL2Ids = /* @__PURE__ */ new Set();
+  knownL3Ids = /* @__PURE__ */ new Map();
+  // id -> updated_at
+  constructor(opts) {
+    this.workerId = opts.workerId;
+    this.primaryUrl = opts.primaryUrl;
+    this.memory = opts.memory;
+    this.syncIntervalMs = opts.syncIntervalMs ?? DEFAULT_SYNC_INTERVAL_MS;
+    opts.server.onSyncPush((req) => this.handlePush(req));
+  }
+  /** Start periodic sync (Worker -> Primary). */
+  start(contextNames) {
+    this.stop();
+    this.syncTimer = setInterval(() => {
+      this.pullTowardsPrimary(contextNames()).catch((err) => {
+        console.warn("[sync] Pull cycle failed:", err.message);
+      });
+    }, this.syncIntervalMs);
+  }
+  /** Stop periodic sync. */
+  stop() {
+    if (this.syncTimer) {
+      clearInterval(this.syncTimer);
+      this.syncTimer = null;
+    }
+  }
+  /**
+   * Pull L3 knowledge from all assigned contexts and send to Primary.
+   * Called periodically by the sync timer.
+   */
+  async pullTowardsPrimary(contextNames) {
+    for (const contextName of contextNames) {
+      try {
+        const entries = await this.memory.getL3Knowledge(contextName);
+        if (entries.length === 0) continue;
+        const syncEntries = entries.map(l3ToSync);
+        const req = {
+          worker_id: this.workerId,
+          context_name: contextName,
+          entries: syncEntries
+        };
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), HEALTH_TIMEOUT_MS);
+        const resp = await fetch(`${this.primaryUrl}${PRIMARY_ROUTES.syncPull}`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(req),
+          signal: controller.signal
+        });
+        clearTimeout(timeout);
+        if (resp.ok) {
+          const result = await resp.json();
+          if (result.accepted > 0) {
+            console.log(`[sync] Pushed ${result.accepted} L3 entries from "${contextName}" to Primary`);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  /**
+   * Handle an incoming push of Global context updates from the Primary.
+   * L3: last-write-wins. L2: append-only.
+   */
+  async handlePush(req) {
+    let l3Accepted = 0;
+    let l2Appended = 0;
+    for (const entry of req.entries) {
+      const existing = this.knownL3Ids.get(entry.id);
+      if (existing && existing >= entry.updated_at) {
+        continue;
+      }
+      try {
+        await this.memory.storeEpisode({
+          context_name: entry.context_name,
+          role: "system",
+          content: entry.content
+        });
+        this.knownL3Ids.set(entry.id, entry.updated_at);
+        l3Accepted++;
+      } catch {
+      }
+    }
+    for (const episode of req.episodes) {
+      if (this.knownL2Ids.has(episode.id)) {
+        continue;
+      }
+      try {
+        await this.memory.storeEpisode({
+          context_name: episode.context_name,
+          role: episode.role,
+          content: episode.content
+        });
+        this.knownL2Ids.add(episode.id);
+        l2Appended++;
+      } catch {
+      }
+    }
+    if (l3Accepted > 0 || l2Appended > 0) {
+      console.log(`[sync] Received push: ${l3Accepted} L3 accepted, ${l2Appended} L2 appended`);
+    }
+    return { l3_accepted: l3Accepted, l2_appended: l2Appended };
+  }
+  getSyncIntervalMs() {
+    return this.syncIntervalMs;
+  }
+};
+var PrimaryMemorySync = class {
+  primary;
+  memory;
+  syncIntervalMs;
+  pushTimer = null;
+  l3Store = /* @__PURE__ */ new Map();
+  // id -> latest entry
+  lastPushAt = (/* @__PURE__ */ new Date(0)).toISOString();
+  constructor(opts) {
+    this.primary = opts.primary;
+    this.memory = opts.memory;
+    this.syncIntervalMs = opts.syncIntervalMs ?? DEFAULT_SYNC_INTERVAL_MS;
+    this.primary.onSyncPull((req) => this.handlePull(req));
+  }
+  /**
+   * Handle an incoming pull — Worker sending L3 knowledge to Primary.
+   * Uses last-write-wins for conflict resolution.
+   */
+  async handlePull(req) {
+    let accepted = 0;
+    let rejected = 0;
+    for (const entry of req.entries) {
+      const existing = this.l3Store.get(entry.id);
+      if (existing && existing.updated_at >= entry.updated_at) {
+        rejected++;
+        continue;
+      }
+      this.l3Store.set(entry.id, entry);
+      try {
+        await this.memory.storeEpisode({
+          context_name: entry.context_name,
+          role: "system",
+          content: entry.content
+        });
+      } catch {
+      }
+      accepted++;
+    }
+    if (accepted > 0) {
+      console.log(
+        `[sync] Accepted ${accepted} L3 entries from worker "${req.worker_id}" context "${req.context_name}"`
+      );
+    }
+    return { accepted, rejected };
+  }
+  /**
+   * Push Global context updates to all workers.
+   * Fetches current Global L3 knowledge and recent L2 episodes,
+   * then pushes to every registered worker.
+   */
+  async pushGlobalToAll() {
+    let l3Entries = [];
+    try {
+      const knowledge = await this.memory.getL3Knowledge("global");
+      l3Entries = knowledge.map(l3ToSync);
+    } catch {
+    }
+    let l2Episodes = [];
+    try {
+      const episodes = await this.memory.getContext("global");
+      l2Episodes = episodes.filter((ep) => ep.timestamp > this.lastPushAt).map(episodeToSync);
+    } catch {
+    }
+    if (l3Entries.length === 0 && l2Episodes.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const payload = {
+      entries: l3Entries,
+      episodes: l2Episodes
+    };
+    this.lastPushAt = (/* @__PURE__ */ new Date()).toISOString();
+    const results = await this.primary.pushSyncToAll(payload);
+    let totalL3 = 0;
+    let totalL2 = 0;
+    for (const resp of results.values()) {
+      if (resp) {
+        totalL3 += resp.l3_accepted;
+        totalL2 += resp.l2_appended;
+      }
+    }
+    if (totalL3 > 0 || totalL2 > 0) {
+      console.log(`[sync] Pushed Global updates: ${totalL3} L3, ${totalL2} L2 across ${results.size} workers`);
+    }
+    return results;
+  }
+  /** Start periodic Global push to all workers. */
+  startPushLoop() {
+    this.stopPushLoop();
+    this.pushTimer = setInterval(() => {
+      this.pushGlobalToAll().catch((err) => {
+        console.warn("[sync] Push cycle failed:", err.message);
+      });
+    }, this.syncIntervalMs);
+  }
+  /** Stop periodic push. */
+  stopPushLoop() {
+    if (this.pushTimer) {
+      clearInterval(this.pushTimer);
+      this.pushTimer = null;
+    }
+  }
+  /** Get all synced L3 entries the Primary has received. */
+  getSyncedEntries() {
+    return Array.from(this.l3Store.values());
+  }
+  getSyncIntervalMs() {
+    return this.syncIntervalMs;
+  }
+};
+
+export {
+  PrimaryClient,
+  FleetManager,
+  WorkerMemorySync,
+  PrimaryMemorySync
+};
+//# sourceMappingURL=chunk-NVJ424TB.js.map