@sesamespace/hivemind 0.3.0 → 0.4.0

package/package.json

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

package/packages/cli/src/commands/upgrade.ts

@@ -0,0 +1,158 @@
+import { execSync } from "child_process";
+import { resolve } from "path";
+import { existsSync, readFileSync } from "fs";
+
+const PACKAGE_NAME = "@sesamespace/hivemind";
+
+interface VersionInfo {
+  current: string;
+  latest: string;
+  updateAvailable: boolean;
+}
+
+function getCurrentVersion(): string {
+  try {
+    // Check the installed package version
+    const output = execSync(`npm ls -g ${PACKAGE_NAME} --json 2>/dev/null`, { encoding: "utf-8" });
+    const parsed = JSON.parse(output);
+    const deps = parsed.dependencies?.[PACKAGE_NAME];
+    if (deps?.version) return deps.version;
+  } catch {
+    // Fallback: read from the package.json in the hivemind dir
+  }
+
+  const hivemindHome = process.env.HIVEMIND_HOME || resolve(process.env.HOME || "~", "hivemind");
+  const pkgPath = resolve(hivemindHome, "node_modules", PACKAGE_NAME, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      return JSON.parse(readFileSync(pkgPath, "utf-8")).version;
+    } catch {
+      // fall through
+    }
+  }
+
+  return "unknown";
+}
+
+function getLatestVersion(target?: string): string {
+  try {
+    const tag = target || "latest";
+    const output = execSync(`npm view ${PACKAGE_NAME}@${tag} version 2>/dev/null`, { encoding: "utf-8" });
+    return output.trim();
+  } catch {
+    throw new Error("Failed to check npm registry for latest version");
+  }
+}
+
+async function checkVersion(target?: string): Promise<VersionInfo> {
+  const current = getCurrentVersion();
+  const latest = target || getLatestVersion();
+  return {
+    current,
+    latest,
+    updateAvailable: current !== latest && current !== "unknown",
+  };
+}
+
+export async function runUpgradeCommand(args: string[]): Promise<void> {
+  const checkOnly = args.includes("--check") || args.includes("-c");
+  const force = args.includes("--force") || args.includes("-f");
+  const dryRun = args.includes("--dry-run") || args.includes("-n");
+
+  // Target version (optional positional arg)
+  const targetVersion = args.find((a) => !a.startsWith("-"));
+
+  if (args.includes("--help") || args.includes("-h")) {
+    printHelp();
+    return;
+  }
+
+  console.log(`
+  ╦ ╦╦╦  ╦╔═╗╔╦╗╦╔╗╔╔╦╗
+  ╠═╣║╚╗╔╝║╣ ║║║║║║║ ║║
+  ╩ ╩╩ ╚╝ ╚═╝╩ ╩╩╝╚╝═╩╝
+  Agent Upgrade
+`);
+
+  // --- Check versions ---
+  console.log("→ Checking versions...");
+  const info = await checkVersion(targetVersion);
+  console.log(`  Current: ${info.current}`);
+  console.log(`  Latest:  ${info.latest}`);
+
+  if (!info.updateAvailable && !force) {
+    console.log("\n  ✓ Already up to date!");
+    return;
+  }
+
+  if (info.updateAvailable) {
+    console.log(`\n  ⬆ Update available: ${info.current} → ${info.latest}`);
+  }
+
+  if (checkOnly) {
+    return;
+  }
+
+  // --- Perform upgrade ---
+  const target = targetVersion ? `${PACKAGE_NAME}@${targetVersion}` : `${PACKAGE_NAME}@latest`;
+
+  if (dryRun) {
+    console.log(`\n→ [dry-run] Would run: npm install -g ${target}`);
+    console.log("→ [dry-run] Would restart the agent service");
+    return;
+  }
+
+  console.log(`\n→ Installing ${target}...`);
+  try {
+    execSync(`npm install -g ${target}`, { stdio: "inherit" });
+    console.log("  ✓ Package updated");
+  } catch (err) {
+    console.error(`  ✗ npm install failed: ${(err as Error).message}`);
+    process.exit(1);
+  }
+
+  // --- Restart agent ---
+  console.log("\n→ Restarting agent...");
+  try {
+    // Try launchctl first (macOS service)
+    const plistName = "com.hivemind.agent";
+    execSync(`launchctl list ${plistName} 2>/dev/null`, { encoding: "utf-8" });
+    // Service exists — restart it
+    execSync(`launchctl kickstart -k gui/$(id -u)/${plistName}`, { stdio: "inherit" });
+    console.log("  ✓ Agent restarted via launchd");
+  } catch {
+    // No launchd service — try finding and restarting the process
+    try {
+      execSync("pkill -f 'hivemind start'", { stdio: "inherit" });
+      console.log("  ✓ Old process killed");
+      console.log("  ! Start the agent manually: hivemind start");
+    } catch {
+      console.log("  ! No running agent found — start manually: hivemind start");
+    }
+  }
+
+  // --- Verify ---
+  const newVersion = getCurrentVersion();
+  console.log(`\n  ✓ Upgrade complete: ${info.current} → ${newVersion}`);
+}
+
+function printHelp(): void {
+  console.log(`hivemind upgrade — Upgrade the Hivemind agent runtime
+
+Usage: hivemind upgrade [version] [options]
+
+Arguments:
+  version          Target version (default: latest)
+
+Options:
+  -c, --check      Check for updates only (don't install)
+  -f, --force      Force reinstall even if up to date
+  -n, --dry-run    Show what would happen without doing it
+  -h, --help       Show this help
+
+Examples:
+  hivemind upgrade              # Upgrade to latest
+  hivemind upgrade 0.3.0        # Upgrade to specific version
+  hivemind upgrade --check      # Just check if update available
+`);
+}

package/packages/cli/src/main.ts

@@ -4,6 +4,7 @@ import { runFleetCommand } from "./commands/fleet.js";
 import { runStartCommand } from "./commands/start.js";
 import { runInitCommand } from "./commands/init.js";
 import { runServiceCommand } from "./commands/service.js";
+import { runUpgradeCommand } from "./commands/upgrade.js";
 
 const [command, ...args] = process.argv.slice(2);
 
@@ -36,14 +37,22 @@ switch (command) {
     });
     break;
 
+  case "upgrade":
+    runUpgradeCommand(args).catch((err) => {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    });
+    break;
+
   default:
-    console.log(`hivemind cli v0.1.0
+    console.log(`hivemind cli v0.3.0
 
 Usage: hivemind <command> [args]
 
 Commands:
   init     Initialize agent from Sesame API key
   start    Start the Hivemind agent
+  upgrade  Upgrade the Hivemind runtime
   service  Manage launchd services (install/uninstall/status/logs)
   fleet    Manage the worker fleet
 `);

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 ──