volute 0.30.1 → 0.31.0

package/dist/{chunk-ZWKTUQEL.js → chunk-NV3TYNWX.js}

@@ -2,7 +2,7 @@
 import {
   stateDir,
   voluteSystemDir
-} from "./chunk-HHTXM4JT.js";
+} from "./chunk-X62AXPR7.js";
 
 // src/lib/env.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";

package/dist/{chunk-NSBFETWP.js → chunk-PNQCXLSV.js}

@@ -5,36 +5,15 @@ import {
 import {
   readGlobalConfig,
   writeGlobalConfig
-} from "./chunk-7D47T4RB.js";
+} from "./chunk-6QIUN46C.js";
 
 // src/lib/ai-service.ts
-import {
-  complete,
-  getEnvApiKey,
-  getModel,
-  getModels,
-  getOAuthApiKey,
-  getProviders
-} from "@mariozechner/pi-ai";
+import { complete, getEnvApiKey, getModel, getModels, getProviders } from "@mariozechner/pi-ai";
+import { getOAuthApiKey } from "@mariozechner/pi-ai/oauth";
 var aiLog = logger_default.child("ai-service");
 function getAiConfig() {
   const config = readGlobalConfig();
-  if (!config.ai) return null;
-  const ai = config.ai;
-  if ("provider" in ai && !("providers" in ai)) {
-    const old = ai;
-    const migrated = {
-      providers: {
-        [old.provider]: {
-          ...old.apiKey ? { apiKey: old.apiKey } : {},
-          ...old.oauth ? { oauth: old.oauth } : {}
-        }
-      }
-    };
-    writeGlobalConfig({ ...config, ai: migrated });
-    return migrated;
-  }
-  return config.ai;
+  return config.ai ?? null;
 }
 function saveProviderConfig(providerId, providerConfig) {
   const ai = getAiConfig() ?? { providers: {} };
@@ -95,7 +74,7 @@ function getAvailableModels() {
     try {
       models.push(...getModels(provider));
     } catch (err) {
-      aiLog.debug(`no models for provider ${provider}`, logger_default.errorData(err));
+      aiLog.warn(`failed to load models for provider ${provider}`, logger_default.errorData(err));
     }
   }
   return models;
@@ -154,6 +133,7 @@ async function aiComplete(systemPrompt, userMessage, modelId) {
   const model = modelId ? findModel(modelId) : autoSelectModel();
   if (!model) {
     if (modelId) aiLog.warn(`model not found: ${modelId}`);
+    else aiLog.debug("no enabled model available for auto-selection");
     return null;
   }
   try {
@@ -184,5 +164,6 @@ export {
   getEnabledModels,
   setEnabledModels,
   getAvailableModels,
+  resolveApiKey,
   aiComplete
 };

package/dist/chunk-R5QJBZZG.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+import {
+  broadcast
+} from "./chunk-EKDWA7E4.js";
+import {
+  getDb,
+  users
+} from "./chunk-X62AXPR7.js";
+
+// src/lib/auth.ts
+import { compareSync, hashSync } from "bcryptjs";
+import { and, count, eq } from "drizzle-orm";
+var userSelectFields = {
+  id: users.id,
+  username: users.username,
+  role: users.role,
+  user_type: users.user_type,
+  display_name: users.display_name,
+  description: users.description,
+  avatar: users.avatar,
+  created_at: users.created_at
+};
+async function createUser(username, password) {
+  const db = await getDb();
+  const hash = hashSync(password, 10);
+  const [{ value }] = await db.select({ value: count() }).from(users).where(eq(users.user_type, "brain"));
+  const role = value === 0 ? "admin" : "pending";
+  const [result] = await db.insert(users).values({ username, password_hash: hash, role }).returning(userSelectFields);
+  return result;
+}
+async function verifyUser(username, password) {
+  const db = await getDb();
+  const row = await db.select().from(users).where(eq(users.username, username)).get();
+  if (!row) return null;
+  if (row.user_type === "mind" || row.user_type === "system") return null;
+  if (!compareSync(password, row.password_hash)) return null;
+  const { password_hash: _, ...user } = row;
+  return user;
+}
+async function getUser(id) {
+  const db = await getDb();
+  const row = await db.select(userSelectFields).from(users).where(eq(users.id, id)).get();
+  return row ?? null;
+}
+async function getUserByUsername(username) {
+  const db = await getDb();
+  const row = await db.select(userSelectFields).from(users).where(eq(users.username, username)).get();
+  return row ?? null;
+}
+async function listUsers() {
+  const db = await getDb();
+  return db.select(userSelectFields).from(users).orderBy(users.created_at).all();
+}
+async function listPendingUsers() {
+  const db = await getDb();
+  return db.select(userSelectFields).from(users).where(eq(users.role, "pending")).orderBy(users.created_at).all();
+}
+async function listUsersByType(userType) {
+  const db = await getDb();
+  return db.select(userSelectFields).from(users).where(eq(users.user_type, userType)).orderBy(users.created_at).all();
+}
+async function getOrCreateMindUser(mindName) {
+  const db = await getDb();
+  const existing = await db.select(userSelectFields).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
+  if (existing) return existing;
+  try {
+    const [result] = await db.insert(users).values({
+      username: mindName,
+      password_hash: "!mind",
+      role: "user",
+      user_type: "mind"
+    }).returning(userSelectFields);
+    return result;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+      const retried = await db.select(userSelectFields).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
+      if (retried) return retried;
+    }
+    throw err;
+  }
+}
+async function getOrCreateSystemUser() {
+  const db = await getDb();
+  const existing = await db.select(userSelectFields).from(users).where(and(eq(users.username, "volute"), eq(users.user_type, "system"))).get();
+  if (existing) return existing;
+  try {
+    const [result] = await db.insert(users).values({
+      username: "volute",
+      password_hash: "!system",
+      role: "user",
+      user_type: "system",
+      display_name: "Volute"
+    }).returning(userSelectFields);
+    return result;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+      const retried = await db.select(userSelectFields).from(users).where(and(eq(users.username, "volute"), eq(users.user_type, "system"))).get();
+      if (retried) return retried;
+    }
+    throw err;
+  }
+}
+async function deleteMindUser(mindName) {
+  const db = await getDb();
+  await db.delete(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind")));
+}
+async function changePassword(userId, currentPassword, newPassword) {
+  const db = await getDb();
+  const row = await db.select().from(users).where(eq(users.id, userId)).get();
+  if (!row) return false;
+  if (!compareSync(currentPassword, row.password_hash)) return false;
+  const hash = hashSync(newPassword, 10);
+  await db.update(users).set({ password_hash: hash }).where(eq(users.id, userId));
+  return true;
+}
+async function approveUser(id) {
+  const db = await getDb();
+  await db.update(users).set({ role: "user" }).where(and(eq(users.id, id), eq(users.role, "pending")));
+}
+async function countAdmins() {
+  const db = await getDb();
+  const [{ value }] = await db.select({ value: count() }).from(users).where(eq(users.role, "admin"));
+  return value;
+}
+async function setUserRole(id, role) {
+  const db = await getDb();
+  const target = await db.select({ id: users.id }).from(users).where(eq(users.id, id)).get();
+  if (!target) throw new Error("User not found");
+  await db.update(users).set({ role }).where(eq(users.id, id));
+}
+async function deleteUser(id) {
+  const db = await getDb();
+  const target = await db.select({ id: users.id }).from(users).where(and(eq(users.id, id), eq(users.user_type, "brain"))).get();
+  if (!target) throw new Error("User not found");
+  await db.delete(users).where(and(eq(users.id, id), eq(users.user_type, "brain")));
+}
+async function updateUserProfile(userId, profile) {
+  const db = await getDb();
+  const target = await db.select({ id: users.id }).from(users).where(eq(users.id, userId)).get();
+  if (!target) throw new Error("User not found");
+  await db.update(users).set(profile).where(eq(users.id, userId));
+}
+async function syncMindProfile(mindName, config) {
+  const user = await getOrCreateMindUser(mindName);
+  const newProfile = {
+    display_name: config.displayName ?? null,
+    description: config.description ?? null,
+    avatar: config.avatar ?? null
+  };
+  const changed = user.display_name !== newProfile.display_name || user.description !== newProfile.description || user.avatar !== newProfile.avatar;
+  if (!changed) return;
+  const db = await getDb();
+  await db.update(users).set(newProfile).where(eq(users.id, user.id));
+  broadcast({ type: "profile_updated", mind: mindName, summary: `${mindName} profile updated` });
+}
+
+export {
+  createUser,
+  verifyUser,
+  getUser,
+  getUserByUsername,
+  listUsers,
+  listPendingUsers,
+  listUsersByType,
+  getOrCreateMindUser,
+  getOrCreateSystemUser,
+  deleteMindUser,
+  changePassword,
+  approveUser,
+  countAdmins,
+  setUserRole,
+  deleteUser,
+  updateUserProfile,
+  syncMindProfile
+};

package/dist/{chunk-MDPCSXZ4.js → chunk-S2TZLSDH.js}

@@ -5,16 +5,16 @@ import {
 import {
   exec,
   gitExec
-} from "./chunk-CVH6Y2YG.js";
+} from "./chunk-57OKQMP3.js";
 import {
   readGlobalConfig,
   writeGlobalConfig
-} from "./chunk-7D47T4RB.js";
+} from "./chunk-6QIUN46C.js";
 import {
   getDb,
   sharedSkills,
   voluteHome
-} from "./chunk-HHTXM4JT.js";
+} from "./chunk-X62AXPR7.js";
 
 // src/lib/skills.ts
 import { createHash } from "crypto";
@@ -42,7 +42,7 @@ async function initDefaultSkills() {
   const config = readGlobalConfig();
   let extensionSkills = [];
   try {
-    const { getExtensionStandardSkills } = await import("./extensions-ECO4RPFQ.js");
+    const { getExtensionStandardSkills } = await import("./extensions-NGEJI7JH.js");
     extensionSkills = getExtensionStandardSkills();
   } catch (err) {
     logger_default.warn("failed to load extension standard skills during init", logger_default.errorData(err));

package/dist/{chunk-FXHXHI2A.js → chunk-SNVPRRT7.js}

@@ -2,11 +2,10 @@
 import {
   exec,
   execInherit
-} from "./chunk-CVH6Y2YG.js";
+} from "./chunk-57OKQMP3.js";
 import {
-  voluteHome,
   voluteSystemDir
-} from "./chunk-HHTXM4JT.js";
+} from "./chunk-X62AXPR7.js";
 
 // src/lib/service-mode.ts
 import { execFileSync } from "child_process";
@@ -170,9 +169,7 @@ async function restartService(mode) {
   }
 }
 function readDaemonConfig() {
-  const newPath = resolve(voluteSystemDir(), "daemon.json");
-  const legacyPath = resolve(voluteHome(), "daemon.json");
-  const configPath = existsSync(newPath) ? newPath : legacyPath;
+  const configPath = resolve(voluteSystemDir(), "daemon.json");
   if (!existsSync(configPath)) return { hostname: "127.0.0.1", port: 1618 };
   try {
     const config = JSON.parse(readFileSync(configPath, "utf-8"));

package/dist/{chunk-UPA6COHU.js → chunk-WRS3B556.js}

@@ -3,7 +3,7 @@ import {
   readEnv,
   sharedEnvPath,
   writeEnv
-} from "./chunk-ZWKTUQEL.js";
+} from "./chunk-NV3TYNWX.js";
 import {
   logger_default
 } from "./chunk-YUIHSKR6.js";
@@ -12,7 +12,7 @@ import {
 } from "./chunk-D424ZQGI.js";
 import {
   voluteSystemDir
-} from "./chunk-HHTXM4JT.js";
+} from "./chunk-X62AXPR7.js";
 
 // src/commands/import.ts
 import {
@@ -112,7 +112,7 @@ async function run(args) {
     return;
   }
   const wsDir = resolveWorkspace(inputPath);
-  const { daemonFetch } = await import("./daemon-client-BCTFGVCZ.js");
+  const { daemonFetch } = await import("./daemon-client-CVGM25DM.js");
   const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
   const client = getClient();
   const res = await daemonFetch(urlOf(client.api.minds.import.$url()), {
@@ -152,7 +152,7 @@ async function importArchive(archivePath, nameOverride) {
     console.error(`File not found: ${archivePath}`);
     process.exit(1);
   }
-  const { extractArchive } = await import("./archive-WWDBWYN2.js");
+  const { extractArchive } = await import("./archive-YBNSJYZZ.js");
   const tempDir = resolve2(tmpdir(), `volute-import-${Date.now()}`);
   mkdirSync(tempDir, { recursive: true });
   let extracted;
@@ -164,7 +164,7 @@ async function importArchive(archivePath, nameOverride) {
     process.exit(1);
   }
   try {
-    const { daemonFetch } = await import("./daemon-client-BCTFGVCZ.js");
+    const { daemonFetch } = await import("./daemon-client-CVGM25DM.js");
     const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
     const client = getClient();
     const res = await daemonFetch(urlOf(client.api.minds.import.$url()), {

package/dist/{chunk-HHTXM4JT.js → chunk-X62AXPR7.js}

@@ -31,6 +31,7 @@ __export(schema_exports, {
   sessions: () => sessions,
   sharedSkills: () => sharedSkills,
   systemPrompts: () => systemPrompts,
+  turns: () => turns,
   users: () => users
 });
 import { sql } from "drizzle-orm";
@@ -72,6 +73,7 @@ var conversations = sqliteTable(
     name: text("name"),
     user_id: integer("user_id").references(() => users.id),
     title: text("title"),
+    private: integer("private").notNull().default(0),
     created_at: text("created_at").notNull().default(sql`(datetime('now'))`),
     updated_at: text("updated_at").notNull().default(sql`(datetime('now'))`)
   },
@@ -82,6 +84,22 @@ var conversations = sqliteTable(
     uniqueIndex("idx_conversations_name").on(table.name)
   ]
 );
+var turns = sqliteTable(
+  "turns",
+  {
+    id: text("id").primaryKey(),
+    mind: text("mind").notNull(),
+    session: text("session"),
+    trigger_event_id: integer("trigger_event_id"),
+    summary_event_id: integer("summary_event_id"),
+    status: text("status").notNull().default("active"),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [
+    index("idx_turns_mind").on(table.mind),
+    index("idx_turns_mind_status").on(table.mind, table.status)
+  ]
+);
 var mindHistory = sqliteTable(
   "mind_history",
   {
@@ -94,12 +112,14 @@ var mindHistory = sqliteTable(
     type: text("type").notNull(),
     content: text("content"),
     metadata: text("metadata"),
+    turn_id: text("turn_id"),
     created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
   },
   (table) => [
     index("idx_mind_history_mind").on(table.mind),
     index("idx_mind_history_mind_channel").on(table.mind, table.channel),
-    index("idx_mind_history_mind_type").on(table.mind, table.type)
+    index("idx_mind_history_mind_type").on(table.mind, table.type),
+    index("idx_mind_history_turn_id").on(table.turn_id)
   ]
 );
 var conversationParticipants = sqliteTable(
@@ -159,11 +179,14 @@ var activity = sqliteTable(
     mind: text("mind").notNull(),
     summary: text("summary").notNull(),
     metadata: text("metadata"),
+    turn_id: text("turn_id"),
+    source_event_id: integer("source_event_id"),
     created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
   },
   (table) => [
     index("idx_activity_created_at").on(table.created_at),
-    index("idx_activity_mind").on(table.mind)
+    index("idx_activity_mind").on(table.mind),
+    index("idx_activity_turn_id").on(table.turn_id)
   ]
 );
 var conversationReads = sqliteTable(
@@ -185,9 +208,14 @@ var messages = sqliteTable(
     role: text("role").notNull(),
     sender_name: text("sender_name"),
     content: text("content").notNull(),
+    source_event_id: integer("source_event_id"),
+    turn_id: text("turn_id"),
     created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
   },
-  (table) => [index("idx_messages_conversation_id").on(table.conversation_id)]
+  (table) => [
+    index("idx_messages_conversation_id").on(table.conversation_id),
+    index("idx_messages_turn_id").on(table.turn_id)
+  ]
 );
 
 // src/lib/registry.ts
@@ -242,12 +270,16 @@ async function readAllMinds() {
 }
 var MIND_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 var MIND_NAME_MAX = 64;
+var RESERVED_NAMES = /* @__PURE__ */ new Set(["volute", "system"]);
 function validateMindName(name) {
   if (!name) return "Mind name is required";
   if (name.length > MIND_NAME_MAX) return `Mind name must be at most ${MIND_NAME_MAX} characters`;
   if (!MIND_NAME_RE.test(name)) {
     return "Mind name must start with alphanumeric and contain only alphanumeric, dots, dashes, or underscores";
   }
+  if (RESERVED_NAMES.has(name.toLowerCase())) {
+    return `"${name}" is a reserved name`;
+  }
   return null;
 }
 async function addMind(name, port, stage, template) {
@@ -346,9 +378,9 @@ async function getDb() {
 }
 
 export {
-  minds,
   users,
   conversations,
+  turns,
   mindHistory,
   conversationParticipants,
   sessions,

package/dist/cli.js

@@ -10,14 +10,13 @@ if (!process.env.VOLUTE_HOME) {
 var command = process.argv[2];
 var args = process.argv.slice(3);
 if (command === "--version" || command === "-v") {
-  const { default: pkg } = await import("./package-OYUD4ZJ4.js");
+  const { default: pkg } = await import("./package-NU4CA7OU.js");
   console.log(pkg.version);
   process.exit(0);
 }
 var ungatedCommands = /* @__PURE__ */ new Set(["setup", "--help", "-h", "--version", "-v", "update", void 0]);
 if (!ungatedCommands.has(command)) {
-  const { isSetupComplete, migrateSetupConfig } = await import("./setup-QMDK5RZX.js");
-  migrateSetupConfig();
+  const { isSetupComplete } = await import("./setup-7CFITEQN.js");
   if (!isSetupComplete()) {
     console.error("Volute is not set up. Run `volute setup` first.");
     process.exit(1);
@@ -25,55 +24,52 @@ if (!ungatedCommands.has(command)) {
 }
 switch (command) {
   case "setup":
-    await import("./setup-XJH3E7YM.js").then((m) => m.run(args));
+    await import("./setup-ZXBXG7E4.js").then((m) => m.run(args));
     break;
   case "mind":
-    await import("./mind-LUWRQUQ5.js").then((m) => m.run(args));
+    await import("./mind-E2ZV2WRX.js").then((m) => m.run(args));
     break;
   case "chat":
-    await import("./chat-TCUNPFGO.js").then((m) => m.run(args));
+    await import("./chat-7YLT7FI3.js").then((m) => m.run(args));
     break;
   case "variant":
     await import("./variant-7TGZHOU3.js").then((m) => m.run(args));
     break;
   case "clock":
-    await import("./clock-G3ALCMLJ.js").then((m) => m.run(args));
-    break;
-  case "schedule":
-    await import("./clock-G3ALCMLJ.js").then((m) => m.run(args));
+    await import("./clock-LJCG426D.js").then((m) => m.run(args));
     break;
   case "skill":
-    await import("./skill-FZIN4W4Q.js").then((m) => m.run(args));
+    await import("./skill-YFXP67A2.js").then((m) => m.run(args));
     break;
   case "env":
-    await import("./env-CLXXT7M2.js").then((m) => m.run(args));
+    await import("./env-NHESNNSP.js").then((m) => m.run(args));
     break;
   case "up":
-    await import("./up-BXUAIDXB.js").then((m) => m.run(args));
+    await import("./up-TDXEP3VA.js").then((m) => m.run(args));
     break;
   case "down":
-    await import("./down-NGBMGORS.js").then((m) => m.run(args));
+    await import("./down-TS4XQBA4.js").then((m) => m.run(args));
     break;
   case "restart":
-    await import("./daemon-restart-4JGBHEJ4.js").then((m) => m.run(args));
+    await import("./daemon-restart-EZP7XH3V.js").then((m) => m.run(args));
     break;
   case "update":
-    await import("./update-PLPHMMZ2.js").then((m) => m.run(args));
+    await import("./update-KUJXATRS.js").then((m) => m.run(args));
     break;
   case "status":
-    await import("./status-ZRO37MWR.js").then((m) => m.run(args));
+    await import("./status-ZZWBYFGE.js").then((m) => m.run(args));
     break;
   case "extension":
-    await import("./extension-WZ4SUPJB.js").then((m) => m.run(args));
+    await import("./extension-LR7EW3JF.js").then((m) => m.run(args));
     break;
   case "systems":
-    await import("./systems-W3BBMSOZ.js").then((m) => m.run(args));
+    await import("./systems-EQPPT4B7.js").then((m) => m.run(args));
     break;
   case "login":
-    await import("./login-RET5WESK.js").then((m) => m.run(args));
+    await import("./login-URWP6S2N.js").then((m) => m.run(args));
     break;
   case "logout":
-    await import("./logout-CGAGJN3L.js").then((m) => m.run(args));
+    await import("./logout-NXJQJDLI.js").then((m) => m.run(args));
     break;
   case "--help":
   case "-h":
@@ -111,6 +107,10 @@ System:
   update                           Update volute
   systems register/login/logout    volute.systems account
 
+Extensions:
+  notes write/list/read/...        Manage notes
+  pages notify                     Notify page updates
+
 Options:
   --version, -v                    Show version number
   --help, -h                       Show this help message
@@ -120,13 +120,64 @@ Run 'volute <command> --help' for details.
 Mind-scoped commands (chat, clock, skill)
 use --mind <name> or VOLUTE_MIND env var to identify the mind.`);
     break;
-  default:
+  default: {
+    let isExtensionCommand = false;
+    try {
+      const { daemonFetch } = await import("./daemon-client-CVGM25DM.js");
+      const res = await daemonFetch("/api/extensions/commands");
+      if (res.ok) {
+        const extCommands = await res.json();
+        if (command && command in extCommands) {
+          isExtensionCommand = true;
+          const subcommand = args[0];
+          const ext = extCommands[command];
+          if (!subcommand || !(subcommand in ext.commands)) {
+            console.log(`volute ${command} \u2014 ${Object.keys(ext.commands).join(", ")}
+`);
+            for (const [name, meta] of Object.entries(ext.commands)) {
+              console.log(`  ${name.padEnd(12)} ${meta.description}`);
+            }
+            process.exit(0);
+          }
+          const cmdArgs = args.slice(1);
+          let mind = process.env.VOLUTE_MIND;
+          const mindIdx = cmdArgs.indexOf("--mind");
+          if (mindIdx !== -1 && cmdArgs[mindIdx + 1]) {
+            mind = cmdArgs[mindIdx + 1];
+            cmdArgs.splice(mindIdx, 2);
+          }
+          const cmdRes = await daemonFetch(`/api/ext/${command}/commands/${subcommand}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ args: cmdArgs, mind })
+          });
+          if (!cmdRes.ok) {
+            const text = await cmdRes.text().catch(() => "");
+            console.error(`Extension command failed (HTTP ${cmdRes.status}): ${text}`);
+            process.exit(1);
+          }
+          const result = await cmdRes.json();
+          if (result.error) {
+            console.error(result.error);
+            process.exit(1);
+          }
+          if (result.output) console.log(result.output);
+          break;
+        }
+      }
+    } catch (err) {
+      if (isExtensionCommand) {
+        console.error(`Extension command failed: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+      }
+    }
     console.error(`Unknown command: ${command}
 Run 'volute --help' for usage.`);
     process.exit(1);
+  }
 }
 if (command !== "update") {
-  import("./update-check-CVCN7MF6.js").then((m) => m.checkForUpdate()).then((result) => {
+  import("./update-check-5WVSU37T.js").then((m) => m.checkForUpdate()).then((result) => {
     if (result.updateAvailable) {
       console.error(`
   Update available: ${result.current} \u2192 ${result.latest}`);