@sesamespace/hivemind 0.3.1 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sesamespace/hivemind",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Cognitive architecture for AI agents with multi-layered memory",
   "scripts": {
     "build": "pnpm -r build",

package/packages/runtime/src/pipeline.ts

@@ -1,7 +1,9 @@
+import { execSync } from "child_process";
 import { Agent } from "./agent.js";
 import type { HivemindConfig } from "./config.js";
 import { loadConfig } from "./config.js";
 import { SesameClient } from "./sesame.js";
+import type { UpgradeRequest } from "./sesame.js";
 import { MemoryClient } from "./memory-client.js";
 
 export async function startPipeline(configPath: string): Promise<void> {
@@ -53,6 +55,40 @@ async function startSesameLoop(config: HivemindConfig, agent: Agent): Promise<vo
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("SIGINT", () => shutdown("SIGINT"));
 
+  // ── Native upgrade handler (no LLM involved) ──
+  sesame.onUpgrade(async (req: UpgradeRequest) => {
+    console.log(`[hivemind] Upgrade requested: ${req.packageName}@${req.targetVersion} (by ${req.requestedBy})`);
+    sesame.updatePresence("working", { detail: `Upgrading to ${req.targetVersion}`, emoji: "⬆️" });
+
+    try {
+      const target = req.targetVersion === "latest"
+        ? req.packageName
+        : `${req.packageName}@${req.targetVersion}`;
+
+      console.log(`[hivemind] Running: npm install -g ${target}`);
+      execSync(`npm install -g ${target}`, { stdio: "inherit", timeout: 120_000 });
+      console.log("[hivemind] Package updated successfully");
+
+      // Send confirmation message to the requesting human's DM
+      // (For now, log it — we'd need the human's channel ID for a proper message)
+      console.log(`[hivemind] Upgrade to ${req.targetVersion} complete. Restarting...`);
+
+      sesame.updatePresence("working", { detail: "Restarting after upgrade", emoji: "🔄" });
+
+      // Graceful restart — try launchd kickstart, fall back to process.exit
+      try {
+        execSync("launchctl kickstart -k gui/$(id -u)/com.hivemind.agent", { timeout: 10_000 });
+      } catch {
+        // If launchd isn't managing us, just exit (the wrapper script will restart)
+        console.log("[hivemind] Exiting for restart...");
+        process.exit(0);
+      }
+    } catch (err) {
+      console.error(`[hivemind] Upgrade failed: ${(err as Error).message}`);
+      sesame.updatePresence("online", { detail: "Upgrade failed", emoji: "❌" });
+    }
+  });
+
   sesame.onMessage(async (msg) => {
     if (shuttingDown) return;
     console.log(`[sesame] ${msg.author.handle} (${msg.channelKind}): ${msg.content}`);

package/packages/runtime/src/sesame.ts

@@ -1,6 +1,20 @@
 import { SesameClient as SesameSDK } from "@sesamespace/sdk";
+import { execSync } from "child_process";
+import { readFileSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
 import type { SesameConfig } from "./config.js";
 
+// Read version at module load time
+let RUNTIME_VERSION = "unknown";
+try {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const pkg = JSON.parse(readFileSync(resolve(__dirname, "../package.json"), "utf-8"));
+  RUNTIME_VERSION = pkg.version ?? "unknown";
+} catch {
+  // give up
+}
+
 export interface SesameMessage {
   id: string;
   channelId: string;
@@ -14,6 +28,14 @@ export interface SesameMessage {
 }
 
 type MessageHandler = (message: SesameMessage) => void | Promise<void>;
+type UpgradeHandler = (event: UpgradeRequest) => void | Promise<void>;
+
+export interface UpgradeRequest {
+  targetVersion: string;
+  packageName: string;
+  requestedBy: string;
+  requestId: string;
+}
 
 interface ChannelInfo {
   kind: "dm" | "group" | "topic";
@@ -24,6 +46,7 @@ export class SesameClient {
   private config: SesameConfig;
   private sdk: SesameSDK;
   private messageHandler: MessageHandler | null = null;
+  private upgradeHandler: UpgradeHandler | null = null;
   private agentId: string | null = null;
   private channels: Map<string, ChannelInfo> = new Map();
   private typingIntervals: Map<string, ReturnType<typeof setInterval>> = new Map();
@@ -41,6 +64,10 @@ export class SesameClient {
     this.messageHandler = handler;
   }
 
+  onUpgrade(handler: UpgradeHandler): void {
+    this.upgradeHandler = handler;
+  }
+
   async connect(): Promise<void> {
     const manifest = await this.sdk.getManifest();
     this.agentId = manifest.agent.id;
@@ -56,6 +83,24 @@ export class SesameClient {
     // Set presence to online
     this.updatePresence("online", { emoji: "🟢" });
 
+    // Listen for upgrade.request control events
+    this.sdk.on("upgrade.request", (event: any) => {
+      console.log(`[sesame] Upgrade request received: ${event.packageName}@${event.targetVersion}`);
+      if (this.upgradeHandler) {
+        this.upgradeHandler({
+          targetVersion: event.targetVersion,
+          packageName: event.packageName,
+          requestedBy: event.requestedBy,
+          requestId: event.requestId,
+        });
+      }
+    });
+
+    // Listen for generic control events
+    this.sdk.on("control", (event: any) => {
+      console.log(`[sesame] Control event: ${event.action}`, event.payload);
+    });
+
     // Listen for message events
     this.sdk.on("message", (event: any) => {
       const msg = event.data || event.message || event;
@@ -83,6 +128,13 @@ export class SesameClient {
 
     await this.sdk.connect();
     console.log("[sesame] WebSocket connected");
+
+    // Report runtime metadata
+    const ws = (this.sdk as any).ws;
+    if (ws?.readyState === 1) {
+      ws.send(JSON.stringify({ type: "meta", runtime: "hivemind", version: RUNTIME_VERSION }));
+      console.log(`[sesame] Reported version: hivemind@${RUNTIME_VERSION}`);
+    }
   }
 
   // ── Typing Indicators ──