volute 0.5.0 → 0.7.0

package/dist/chunk-ZZOOTYXK.js

@@ -0,0 +1,583 @@
+#!/usr/bin/env node
+import {
+  resolveChannelId,
+  slugify,
+  writeChannelEntry
+} from "./chunk-BX7KI4S3.js";
+import {
+  voluteHome
+} from "./chunk-UWHWAPGO.js";
+import {
+  __export
+} from "./chunk-K3NQKI34.js";
+
+// src/lib/channels/discord.ts
+var discord_exports = {};
+__export(discord_exports, {
+  createConversation: () => createConversation,
+  listConversations: () => listConversations,
+  listUsers: () => listUsers,
+  read: () => read,
+  send: () => send
+});
+var API_BASE = "https://discord.com/api/v10";
+function requireToken(env) {
+  const token = env.DISCORD_TOKEN;
+  if (!token) throw new Error("DISCORD_TOKEN not set");
+  return token;
+}
+async function discordGet(token, path) {
+  const res = await fetch(`${API_BASE}${path}`, {
+    headers: { Authorization: `Bot ${token}` }
+  });
+  if (!res.ok) {
+    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+async function read(env, channelSlug, limit) {
+  const token = requireToken(env);
+  const channelId = resolveChannelId2(env, channelSlug);
+  const res = await fetch(`${API_BASE}/channels/${channelId}/messages?limit=${limit}`, {
+    headers: { Authorization: `Bot ${token}` }
+  });
+  if (!res.ok) {
+    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
+  }
+  const messages = await res.json();
+  return messages.reverse().map((m) => `${m.author.username}: ${m.content}`).join("\n");
+}
+async function send(env, channelSlug, message) {
+  const token = requireToken(env);
+  const channelId = resolveChannelId2(env, channelSlug);
+  const res = await fetch(`${API_BASE}/channels/${channelId}/messages`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bot ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ content: message })
+  });
+  if (!res.ok) {
+    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
+  }
+}
+async function listConversations(env) {
+  const token = requireToken(env);
+  const results = [];
+  const guilds = await discordGet(token, "/users/@me/guilds");
+  for (const guild of guilds) {
+    const channels = await discordGet(token, `/guilds/${guild.id}/channels`);
+    for (const ch of channels) {
+      if (ch.type !== 0) continue;
+      results.push({
+        id: `discord:${slugify(guild.name)}/${slugify(ch.name)}`,
+        platformId: ch.id,
+        name: `#${ch.name}`,
+        type: "channel"
+      });
+    }
+  }
+  const dms = await discordGet(token, "/users/@me/channels");
+  for (const dm of dms) {
+    const recipients = dm.recipients?.map((r) => r.username) ?? [];
+    const slug = recipients.length === 0 ? `discord:${dm.id}` : recipients.length === 1 ? `discord:@${slugify(recipients[0])}` : `discord:@${recipients.map(slugify).sort().join(",")}`;
+    results.push({
+      id: slug,
+      platformId: dm.id,
+      name: recipients.join(", ") || "DM",
+      type: dm.type === 1 ? "dm" : "group"
+    });
+  }
+  return results;
+}
+async function listUsers(env) {
+  const token = requireToken(env);
+  const seen = /* @__PURE__ */ new Map();
+  const guilds = await discordGet(token, "/users/@me/guilds");
+  for (const guild of guilds) {
+    const members = await discordGet(token, `/guilds/${guild.id}/members?limit=1000`);
+    for (const m of members) {
+      if (!seen.has(m.user.id)) {
+        seen.set(m.user.id, {
+          id: m.user.id,
+          username: m.user.username,
+          type: m.user.bot ? "bot" : "human"
+        });
+      }
+    }
+  }
+  return [...seen.values()];
+}
+async function createConversation(env, participants, _name) {
+  const token = requireToken(env);
+  if (participants.length !== 1) {
+    throw new Error(
+      "Discord group creation not supported via bot \u2014 use threads in an existing channel"
+    );
+  }
+  const allUsers = await listUsers(env);
+  const target = allUsers.find((u) => u.username.toLowerCase() === participants[0].toLowerCase());
+  if (!target) {
+    throw new Error(`User not found: ${participants[0]}`);
+  }
+  const res = await fetch(`${API_BASE}/users/@me/channels`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bot ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ recipient_id: target.id })
+  });
+  if (!res.ok) {
+    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
+  }
+  const dm = await res.json();
+  const slug = `discord:@${slugify(participants[0])}`;
+  const agentDir = env.VOLUTE_AGENT_DIR;
+  if (agentDir) {
+    writeChannelEntry(agentDir, slug, {
+      platformId: dm.id,
+      platform: "discord",
+      name: participants[0],
+      type: "dm"
+    });
+  }
+  return slug;
+}
+
+// src/lib/channels/slack.ts
+var slack_exports = {};
+__export(slack_exports, {
+  createConversation: () => createConversation2,
+  listConversations: () => listConversations2,
+  listUsers: () => listUsers2,
+  read: () => read2,
+  send: () => send2
+});
+var API_BASE2 = "https://slack.com/api";
+function requireToken2(env) {
+  const token = env.SLACK_BOT_TOKEN;
+  if (!token) throw new Error("SLACK_BOT_TOKEN not set");
+  return token;
+}
+async function slackApi(token, method, body) {
+  const res = await fetch(`${API_BASE2}/${method}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    throw new Error(`Slack API HTTP error: ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  if (!data.ok) {
+    throw new Error(`Slack API error: ${data.error}`);
+  }
+  return data;
+}
+async function read2(env, channelSlug, limit) {
+  const token = requireToken2(env);
+  const channelId = resolveChannelId2(env, channelSlug);
+  const data = await slackApi(token, "conversations.history", {
+    channel: channelId,
+    limit
+  });
+  return data.messages.reverse().map((m) => `${m.user ?? m.bot_id ?? "unknown"}: ${m.text}`).join("\n");
+}
+async function send2(env, channelSlug, message) {
+  const token = requireToken2(env);
+  const channelId = resolveChannelId2(env, channelSlug);
+  await slackApi(token, "chat.postMessage", {
+    channel: channelId,
+    text: message
+  });
+}
+async function listConversations2(env) {
+  const token = requireToken2(env);
+  const authData = await slackApi(token, "auth.test", {});
+  const teamName = authData.team ?? "workspace";
+  const data = await slackApi(token, "conversations.list", {
+    types: "public_channel,private_channel,mpim,im",
+    limit: 1e3
+  });
+  const userMap = /* @__PURE__ */ new Map();
+  const imChannels = data.channels.filter((ch) => ch.is_im && ch.user);
+  if (imChannels.length > 0) {
+    const users = await listUsers2(env);
+    for (const u of users) {
+      userMap.set(u.id, u.username);
+    }
+  }
+  return data.channels.map((ch) => {
+    let type = "channel";
+    if (ch.is_im) type = "dm";
+    else if (ch.is_mpim) type = "group";
+    let slug;
+    let name;
+    if (ch.is_im && ch.user) {
+      const username = userMap.get(ch.user) ?? ch.user;
+      slug = `slack:@${slugify(username)}`;
+      name = username;
+    } else if (ch.name) {
+      slug = `slack:${slugify(teamName)}/${slugify(ch.name)}`;
+      name = ch.name;
+    } else {
+      slug = `slack:${ch.id}`;
+      name = ch.id;
+    }
+    return {
+      id: slug,
+      platformId: ch.id,
+      name,
+      type,
+      participantCount: ch.num_members
+    };
+  });
+}
+async function listUsers2(env) {
+  const token = requireToken2(env);
+  const data = await slackApi(token, "users.list", {});
+  return data.members.filter((m) => !m.deleted).map((m) => ({
+    id: m.id,
+    username: m.name,
+    type: m.is_bot ? "bot" : "human"
+  }));
+}
+async function createConversation2(env, participants, name) {
+  const token = requireToken2(env);
+  const allUsers = await listUsers2(env);
+  const ids = [];
+  for (const p of participants) {
+    const user = allUsers.find((u) => u.username.toLowerCase() === p.toLowerCase());
+    if (!user) throw new Error(`User not found: ${p}`);
+    ids.push(user.id);
+  }
+  const agentDir = env.VOLUTE_AGENT_DIR;
+  if (name) {
+    const createData = await slackApi(token, "conversations.create", {
+      name,
+      is_private: true
+    });
+    const channelId = createData.channel.id;
+    for (const userId of ids) {
+      await slackApi(token, "conversations.invite", {
+        channel: channelId,
+        users: userId
+      });
+    }
+    const authData = await slackApi(token, "auth.test", {});
+    const teamName = authData.team ?? "workspace";
+    const slug2 = `slack:${slugify(teamName)}/${slugify(name)}`;
+    if (agentDir) {
+      writeChannelEntry(agentDir, slug2, {
+        platformId: channelId,
+        platform: "slack",
+        name,
+        type: "channel"
+      });
+    }
+    return slug2;
+  }
+  const openData = await slackApi(token, "conversations.open", {
+    users: ids.join(",")
+  });
+  const platformId = openData.channel.id;
+  const slug = participants.length === 1 ? `slack:@${slugify(participants[0])}` : `slack:@${participants.map(slugify).sort().join(",")}`;
+  if (agentDir) {
+    writeChannelEntry(agentDir, slug, {
+      platformId,
+      platform: "slack",
+      name: participants.join(", "),
+      type: participants.length === 1 ? "dm" : "group"
+    });
+  }
+  return slug;
+}
+
+// src/lib/channels/telegram.ts
+var telegram_exports = {};
+__export(telegram_exports, {
+  createConversation: () => createConversation3,
+  listConversations: () => listConversations3,
+  listUsers: () => listUsers3,
+  read: () => read3,
+  send: () => send3
+});
+var API_BASE3 = "https://api.telegram.org";
+function requireToken3(env) {
+  const token = env.TELEGRAM_BOT_TOKEN;
+  if (!token) throw new Error("TELEGRAM_BOT_TOKEN not set");
+  return token;
+}
+async function read3(_env, _channelSlug, _limit) {
+  throw new Error(
+    "Telegram Bot API does not support reading chat history. Use volute channel send instead."
+  );
+}
+async function send3(env, channelSlug, message) {
+  const token = requireToken3(env);
+  const chatId = resolveChannelId2(env, channelSlug);
+  const res = await fetch(`${API_BASE3}/bot${token}/sendMessage`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ chat_id: chatId, text: message })
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Telegram API error: ${res.status} ${body}`);
+  }
+}
+async function listConversations3() {
+  throw new Error(
+    "Telegram Bot API does not support listing conversations. Users must message the bot first."
+  );
+}
+async function listUsers3() {
+  throw new Error(
+    "Telegram Bot API does not support listing users. Users must message the bot first."
+  );
+}
+async function createConversation3() {
+  throw new Error(
+    "Telegram Bot API does not support creating conversations. Users must message the bot first."
+  );
+}
+
+// src/lib/channels/volute.ts
+var volute_exports = {};
+__export(volute_exports, {
+  createConversation: () => createConversation4,
+  listConversations: () => listConversations4,
+  listUsers: () => listUsers4,
+  read: () => read4,
+  send: () => send4,
+  sendAndStream: () => sendAndStream
+});
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+function getDaemonConfig() {
+  const configPath = resolve(voluteHome(), "daemon.json");
+  if (!existsSync(configPath)) {
+    throw new Error("Volute daemon is not running");
+  }
+  let config;
+  try {
+    config = JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch (err) {
+    throw new Error(`Failed to parse ${configPath}: ${err}`);
+  }
+  if (typeof config.port !== "number") {
+    throw new Error(`Invalid or missing port in ${configPath}`);
+  }
+  const url = new URL("http://localhost");
+  url.hostname = config.hostname || "localhost";
+  url.port = String(config.port);
+  return { url: url.origin, token: config.token };
+}
+async function read4(env, channelSlug, limit) {
+  const agentName = env.VOLUTE_AGENT;
+  if (!agentName) throw new Error("VOLUTE_AGENT not set");
+  const conversationId = resolveChannelId2(env, channelSlug);
+  const { url, token } = getDaemonConfig();
+  const headers = { Origin: url };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(
+    `${url}/api/agents/${encodeURIComponent(agentName)}/conversations/${encodeURIComponent(conversationId)}/messages`,
+    { headers }
+  );
+  if (!res.ok) {
+    throw new Error(`Failed to read conversation: ${res.status} ${res.statusText}`);
+  }
+  const messages = await res.json();
+  return messages.slice(-limit).map((m) => {
+    const text = Array.isArray(m.content) ? m.content.filter((b) => b.type === "text").map((b) => b.text).join("") : m.content;
+    return `${m.sender_name ?? m.role}: ${text}`;
+  }).join("\n");
+}
+async function* sendAndStream(env, channelSlug, message) {
+  const agentName = env.VOLUTE_AGENT;
+  if (!agentName) throw new Error("VOLUTE_AGENT not set");
+  const conversationId = resolveChannelId2(env, channelSlug);
+  const { url, token } = getDaemonConfig();
+  const headers = {
+    "Content-Type": "application/json",
+    Origin: url
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(`${url}/api/agents/${encodeURIComponent(agentName)}/chat`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ message, conversationId, sender: env.VOLUTE_SENDER ?? agentName })
+  });
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    throw new Error(data.error ?? `Failed to send: ${res.status}`);
+  }
+  if (!res.body) return;
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.startsWith("data:")) continue;
+        const data = line.slice(5).trim();
+        if (!data) continue;
+        try {
+          const event = JSON.parse(data);
+          yield event;
+          if (event.type === "done") return;
+        } catch (err) {
+          console.error(`[volute] failed to parse SSE data: ${data}`, err);
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function send4(env, channelSlug, message) {
+  for await (const event of sendAndStream(env, channelSlug, message)) {
+    if (event.type === "done") break;
+  }
+}
+async function listConversations4(env) {
+  const agentName = env.VOLUTE_AGENT;
+  if (!agentName) throw new Error("VOLUTE_AGENT not set");
+  const { url, token } = getDaemonConfig();
+  const headers = { Origin: url };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(`${url}/api/agents/${encodeURIComponent(agentName)}/conversations`, {
+    headers
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to list conversations: ${res.status} ${res.statusText}`);
+  }
+  const convs = await res.json();
+  const results = [];
+  for (const conv of convs) {
+    let participantCount;
+    try {
+      const pRes = await fetch(
+        `${url}/api/agents/${encodeURIComponent(agentName)}/conversations/${encodeURIComponent(conv.id)}/participants`,
+        { headers }
+      );
+      if (pRes.ok) {
+        const participants = await pRes.json();
+        participantCount = participants.length;
+      }
+    } catch (err) {
+      console.error(`[volute] failed to fetch participants for ${conv.id}:`, err);
+    }
+    const slug = conv.title ? `volute:${slugify(conv.title)}` : `volute:${conv.id}`;
+    results.push({
+      id: slug,
+      platformId: conv.id,
+      name: conv.title ?? "(untitled)",
+      type: participantCount === 2 ? "dm" : "group",
+      participantCount
+    });
+  }
+  return results;
+}
+async function listUsers4(_env) {
+  const { url, token } = getDaemonConfig();
+  const headers = { Origin: url };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(`${url}/api/auth/users`, { headers });
+  if (!res.ok) {
+    throw new Error(`Failed to list users: ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  return data.map((u) => ({
+    id: String(u.id),
+    username: u.username,
+    type: u.user_type
+  }));
+}
+async function createConversation4(env, participants, name) {
+  const agentName = env.VOLUTE_AGENT;
+  if (!agentName) throw new Error("VOLUTE_AGENT not set");
+  const { url, token } = getDaemonConfig();
+  const headers = {
+    "Content-Type": "application/json",
+    Origin: url
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(`${url}/api/agents/${encodeURIComponent(agentName)}/conversations`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ participantNames: participants, title: name })
+  });
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    throw new Error(data.error ?? `Failed to create conversation: ${res.status}`);
+  }
+  const conv = await res.json();
+  const slug = name ? `volute:${slugify(name)}` : `volute:${conv.id}`;
+  const agentDir = env.VOLUTE_AGENT_DIR;
+  if (agentDir) {
+    writeChannelEntry(agentDir, slug, {
+      platformId: conv.id,
+      platform: "volute",
+      name: name ?? participants.join(", "),
+      type: participants.length <= 1 ? "dm" : "group"
+    });
+  }
+  return slug;
+}
+
+// src/lib/channels.ts
+var CHANNELS = {
+  volute: {
+    name: "volute",
+    displayName: "Volute",
+    showToolCalls: true,
+    builtIn: true,
+    driver: volute_exports
+  },
+  discord: {
+    name: "discord",
+    displayName: "Discord",
+    showToolCalls: false,
+    driver: discord_exports
+  },
+  slack: {
+    name: "slack",
+    displayName: "Slack",
+    showToolCalls: false,
+    driver: slack_exports
+  },
+  telegram: {
+    name: "telegram",
+    displayName: "Telegram",
+    showToolCalls: false,
+    driver: telegram_exports
+  },
+  system: { name: "system", displayName: "System", showToolCalls: false }
+};
+function getChannelDriver(platform) {
+  return CHANNELS[platform]?.driver ?? null;
+}
+function resolveChannelId2(env, slug) {
+  const agentDir = env.VOLUTE_AGENT_DIR;
+  if (!agentDir) {
+    const colonIdx = slug.indexOf(":");
+    return colonIdx !== -1 ? slug.slice(colonIdx + 1) : slug;
+  }
+  return resolveChannelId(agentDir, slug);
+}
+
+export {
+  CHANNELS,
+  getChannelDriver
+};

package/dist/cli.js

@@ -9,49 +9,49 @@ 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-VQOE7JNH.js");
+  const { default: pkg } = await import("./package-T2WAVJOU.js");
   console.log(pkg.version);
   process.exit(0);
 }
 switch (command) {
   case "agent":
-    await import("./agent-Z2B6EFEQ.js").then((m) => m.run(args));
+    await import("./agent-7JF7MT73.js").then((m) => m.run(args));
     break;
   case "message":
-    await import("./message-ADHWFHSI.js").then((m) => m.run(args));
+    await import("./message-SCOQDR3P.js").then((m) => m.run(args));
     break;
   case "variant":
-    await import("./variant-LAB67OC2.js").then((m) => m.run(args));
+    await import("./variant-4Z6W3PP6.js").then((m) => m.run(args));
     break;
   case "connector":
-    await import("./connector-LYEMXQEV.js").then((m) => m.run(args));
+    await import("./connector-Y7JPNROO.js").then((m) => m.run(args));
     break;
   case "channel":
-    await import("./channel-MK5OK2SI.js").then((m) => m.run(args));
+    await import("./channel-SMCNOIVQ.js").then((m) => m.run(args));
     break;
   case "schedule":
-    await import("./schedule-NAG6F463.js").then((m) => m.run(args));
-    break;
-  case "conversation":
-    await import("./conversation-ERXEQZTY.js").then((m) => m.run(args));
+    await import("./schedule-S6QVC5ON.js").then((m) => m.run(args));
     break;
   case "env":
-    await import("./env-4D4REPJF.js").then((m) => m.run(args));
+    await import("./env-7GLUJCWS.js").then((m) => m.run(args));
     break;
   case "up":
-    await import("./up-7ILD7GU7.js").then((m) => m.run(args));
+    await import("./up-RWZF6MLT.js").then((m) => m.run(args));
     break;
   case "down":
-    await import("./down-O7IFZLVJ.js").then((m) => m.run(args));
+    await import("./down-AZVH5TCD.js").then((m) => m.run(args));
+    break;
+  case "restart":
+    await import("./daemon-restart-4HVEKYFY.js").then((m) => m.run(args));
     break;
   case "setup":
-    await import("./setup-RPRRGG2F.js").then((m) => m.run(args));
+    await import("./setup-F4TCWVSP.js").then((m) => m.run(args));
     break;
   case "service":
     await import("./service-HZNIDNJF.js").then((m) => m.run(args));
     break;
   case "update":
-    await import("./update-LPSIAWQ2.js").then((m) => m.run(args));
+    await import("./update-F7QWV2LB.js").then((m) => m.run(args));
     break;
   case "--help":
   case "-h":
@@ -62,6 +62,7 @@ Commands:
   volute agent create <name>              Create a new agent
   volute agent start <name>               Start an agent (daemonized)
   volute agent stop <name>                Stop an agent
+  volute agent restart <name>             Restart an agent
   volute agent delete <name> [--force]    Delete an agent (--force removes files)
   volute agent list                       List all agents
   volute agent status <name>              Check agent status
@@ -82,19 +83,19 @@ Commands:
 
   volute channel read <uri>               Read recent messages from a channel
   volute channel send <uri> "<msg>"       Send a message to a channel
+  volute channel list [<platform>]        List conversations on a platform
+  volute channel users <platform>         List users on a platform
+  volute channel create <platform> ...    Create a conversation on a platform
 
   volute schedule list                    List schedules for an agent
   volute schedule add ...                 Add a cron schedule
   volute schedule remove ...              Remove a schedule
 
-  volute conversation create ...           Create a group conversation
-  volute conversation list                 List conversations
-  volute conversation send <id> "<msg>"    Send a message to a conversation
-
   volute env <set|get|list|remove>        Manage environment variables
 
   volute up [--port N]                    Start the daemon (default: 4200)
   volute down                             Stop the daemon
+  volute restart [--port N]               Restart the daemon
 
   volute service install [--port N]       Install as system service (auto-start)
   volute service uninstall                Remove system service
@@ -108,7 +109,7 @@ Options:
   --version, -v                           Show version number
   --help, -h                              Show this help message
 
-Agent-scoped commands (variant, connector, schedule, channel, conversation, message history)
+Agent-scoped commands (variant, connector, schedule, channel, message history)
 use --agent <name> or VOLUTE_AGENT env var to identify the agent.`);
     break;
   default:
@@ -117,7 +118,7 @@ Run 'volute --help' for usage.`);
     process.exit(1);
 }
 if (command !== "update") {
-  import("./update-check-Y33QDCFL.js").then((m) => m.checkForUpdate()).then((result) => {
+  import("./update-check-B4J6IEQ4.js").then((m) => m.checkForUpdate()).then((result) => {
     if (result.updateAvailable) {
       console.error(`
   Update available: ${result.current} \u2192 ${result.latest}`);