@sesamespace/hivemind 0.2.0 → 0.3.0

package/dist/chunk-NVJ424TB.js

@@ -1,731 +0,0 @@
-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