volute 0.19.0 → 0.21.0

package/dist/chunk-UJ6GHNR7.js

@@ -1,675 +0,0 @@
-#!/usr/bin/env node
-import {
-  buildVoluteSlug,
-  resolveChannelId,
-  slugify,
-  splitMessage,
-  writeChannelEntry
-} from "./chunk-RHEGSQFJ.js";
-import {
-  voluteHome
-} from "./chunk-EBGCNDMM.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 DISCORD_MAX_LENGTH = 2e3;
-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, images) {
-  const token = requireToken(env);
-  const channelId = resolveChannelId2(env, channelSlug);
-  if (images?.length) {
-    for (let i = 0; i < images.length; i++) {
-      const img = images[i];
-      const ext = img.media_type.split("/")[1] || "png";
-      const form = new FormData();
-      const content = i === 0 ? message.slice(0, DISCORD_MAX_LENGTH) : "";
-      form.append("payload_json", JSON.stringify({ content }));
-      form.append(
-        "files[0]",
-        new Blob([Buffer.from(img.data, "base64")], { type: img.media_type }),
-        `image.${ext}`
-      );
-      const res = await fetch(`${API_BASE}/channels/${channelId}/messages`, {
-        method: "POST",
-        headers: { Authorization: `Bot ${token}` },
-        body: form
-      });
-      if (!res.ok) {
-        const body = await res.text().catch(() => "");
-        const partial = i > 0 ? ` (${i}/${images.length} images were already sent)` : "";
-        throw new Error(`Discord API error: ${res.status} ${body || res.statusText}${partial}`);
-      }
-    }
-    return;
-  }
-  const chunks = splitMessage(message, DISCORD_MAX_LENGTH);
-  for (let i = 0; i < chunks.length; i++) {
-    const res = await fetch(`${API_BASE}/channels/${channelId}/messages`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bot ${token}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ content: chunks[i] })
-    });
-    if (!res.ok) {
-      const partial = i > 0 ? ` (${i}/${chunks.length} chunks were already sent)` : "";
-      throw new Error(`Discord API error: ${res.status} ${res.statusText}${partial}`);
-    }
-  }
-}
-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 mindName = env.VOLUTE_MIND;
-  if (mindName) {
-    writeChannelEntry(mindName, 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 SLACK_MAX_LENGTH = 4e3;
-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, images) {
-  const token = requireToken2(env);
-  const channelId = resolveChannelId2(env, channelSlug);
-  if (images?.length) {
-    for (const img of images) {
-      const ext = img.media_type.split("/")[1] || "png";
-      const filename = `image.${ext}`;
-      const binary = Buffer.from(img.data, "base64");
-      const uploadData = await slackApi(token, "files.getUploadURLExternal", {
-        filename,
-        length: binary.length
-      });
-      const uploadRes = await fetch(uploadData.upload_url, {
-        method: "POST",
-        body: binary
-      });
-      if (!uploadRes.ok) {
-        throw new Error(`Slack file upload failed: ${uploadRes.status} ${uploadRes.statusText}`);
-      }
-      await slackApi(token, "files.completeUploadExternal", {
-        files: [{ id: uploadData.file_id }],
-        channel_id: channelId
-      });
-    }
-    if (message) {
-      const chunks2 = splitMessage(message, SLACK_MAX_LENGTH);
-      for (const chunk of chunks2) {
-        await slackApi(token, "chat.postMessage", {
-          channel: channelId,
-          text: chunk
-        });
-      }
-    }
-    return;
-  }
-  const chunks = splitMessage(message, SLACK_MAX_LENGTH);
-  for (let i = 0; i < chunks.length; i++) {
-    try {
-      await slackApi(token, "chat.postMessage", {
-        channel: channelId,
-        text: chunks[i]
-      });
-    } catch (err) {
-      const partial = i > 0 ? ` (${i}/${chunks.length} chunks were already sent)` : "";
-      throw new Error(`${err instanceof Error ? err.message : err}${partial}`);
-    }
-  }
-}
-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 mindName = env.VOLUTE_MIND;
-  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 (mindName) {
-      writeChannelEntry(mindName, 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 (mindName) {
-    writeChannelEntry(mindName, 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 TELEGRAM_MAX_LENGTH = 4096;
-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 send instead."
-  );
-}
-async function send3(env, channelSlug, message, images) {
-  const token = requireToken3(env);
-  const chatId = resolveChannelId2(env, channelSlug);
-  if (images?.length) {
-    const CAPTION_MAX = 1024;
-    for (let i = 0; i < images.length; i++) {
-      const img = images[i];
-      const ext = img.media_type.split("/")[1] || "png";
-      const form = new FormData();
-      form.append("chat_id", chatId);
-      form.append(
-        "photo",
-        new Blob([Buffer.from(img.data, "base64")], { type: img.media_type }),
-        `image.${ext}`
-      );
-      if (i === 0 && message) {
-        form.append("caption", message.slice(0, CAPTION_MAX));
-      }
-      const res = await fetch(`${API_BASE3}/bot${token}/sendPhoto`, {
-        method: "POST",
-        body: form
-      });
-      if (!res.ok) {
-        const body = await res.text().catch(() => "");
-        const partial = i > 0 ? ` (${i}/${images.length} images were already sent)` : "";
-        throw new Error(`Telegram API error: ${res.status} ${body}${partial}`);
-      }
-    }
-    if (message && message.length > CAPTION_MAX) {
-      const remaining = message.slice(CAPTION_MAX);
-      const chunks2 = splitMessage(remaining, TELEGRAM_MAX_LENGTH);
-      for (const chunk of chunks2) {
-        const res = await fetch(`${API_BASE3}/bot${token}/sendMessage`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ chat_id: chatId, text: chunk })
-        });
-        if (!res.ok) {
-          const body = await res.text().catch(() => "");
-          throw new Error(`Telegram API error: ${res.status} ${body}`);
-        }
-      }
-    }
-    return;
-  }
-  const chunks = splitMessage(message, TELEGRAM_MAX_LENGTH);
-  for (let i = 0; i < chunks.length; i++) {
-    const res = await fetch(`${API_BASE3}/bot${token}/sendMessage`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ chat_id: chatId, text: chunks[i] })
-    });
-    if (!res.ok) {
-      const body = await res.text().catch(() => "");
-      const partial = i > 0 ? ` (${i}/${chunks.length} chunks were already sent)` : "";
-      throw new Error(`Telegram API error: ${res.status} ${body}${partial}`);
-    }
-  }
-}
-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
-});
-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 mindName = env.VOLUTE_MIND;
-  if (!mindName) throw new Error("VOLUTE_MIND 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/minds/${encodeURIComponent(mindName)}/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 send4(env, channelSlug, message, images) {
-  const mindName = env.VOLUTE_MIND;
-  if (!mindName) throw new Error("VOLUTE_MIND 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/minds/${encodeURIComponent(mindName)}/chat`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({
-      message,
-      conversationId,
-      sender: env.VOLUTE_SENDER ?? mindName,
-      images
-    })
-  });
-  if (!res.ok) {
-    const data = await res.json().catch(() => ({}));
-    throw new Error(data.error ?? `Failed to send: ${res.status}`);
-  }
-}
-async function listConversations4(env) {
-  const mindName = env.VOLUTE_MIND;
-  if (!mindName) throw new Error("VOLUTE_MIND not set");
-  const { url, token } = getDaemonConfig();
-  const headers = { Origin: url };
-  if (token) headers.Authorization = `Bearer ${token}`;
-  const res = await fetch(`${url}/api/minds/${encodeURIComponent(mindName)}/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 participants = [];
-    try {
-      const pRes = await fetch(
-        `${url}/api/minds/${encodeURIComponent(mindName)}/conversations/${encodeURIComponent(conv.id)}/participants`,
-        { headers }
-      );
-      if (pRes.ok) {
-        participants = await pRes.json();
-      } else {
-        console.error(`[volute] failed to fetch participants for ${conv.id}: HTTP ${pRes.status}`);
-      }
-    } catch (err) {
-      console.error(`[volute] failed to fetch participants for ${conv.id}:`, err);
-    }
-    const slug = buildVoluteSlug({
-      participants,
-      mindUsername: mindName,
-      convTitle: conv.title,
-      conversationId: conv.id,
-      convType: conv.type,
-      convName: conv.name
-    });
-    const convType = conv.type === "channel" ? "channel" : participants.length === 2 ? "dm" : "group";
-    results.push({
-      id: slug,
-      platformId: conv.id,
-      name: conv.type === "channel" ? `#${conv.name}` : conv.title ?? "(untitled)",
-      type: convType,
-      participantCount: participants.length
-    });
-  }
-  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 mindName = env.VOLUTE_MIND;
-  if (!mindName) throw new Error("VOLUTE_MIND 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/minds/${encodeURIComponent(mindName)}/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();
-  return `volute:${conv.id}`;
-}
-
-// 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
-  },
-  mail: { name: "mail", displayName: "Email", showToolCalls: false },
-  system: { name: "system", displayName: "System", showToolCalls: false }
-};
-function getChannelDriver(platform) {
-  return CHANNELS[platform]?.driver ?? null;
-}
-function resolveChannelId2(env, slug) {
-  const mindName = env.VOLUTE_MIND;
-  if (!mindName) {
-    const colonIdx = slug.indexOf(":");
-    return colonIdx !== -1 ? slug.slice(colonIdx + 1) : slug;
-  }
-  return resolveChannelId(mindName, slug);
-}
-
-export {
-  CHANNELS,
-  getChannelDriver
-};

package/dist/chunk-Z524RFCJ.js

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-import {
-  schema_exports
-} from "./chunk-VQWDC6UK.js";
-import {
-  voluteHome
-} from "./chunk-EBGCNDMM.js";
-
-// src/lib/db.ts
-import { chmodSync, existsSync } from "fs";
-import { dirname, resolve } from "path";
-import { fileURLToPath } from "url";
-import { drizzle } from "drizzle-orm/libsql";
-import { migrate } from "drizzle-orm/libsql/migrator";
-var __dirname = dirname(fileURLToPath(import.meta.url));
-var migrationsFolder = existsSync(resolve(__dirname, "../drizzle")) ? resolve(__dirname, "../drizzle") : resolve(__dirname, "../../drizzle");
-var db = null;
-async function getDb() {
-  if (db) return db;
-  const dbPath = process.env.VOLUTE_DB_PATH || resolve(voluteHome(), "volute.db");
-  db = drizzle({ connection: { url: `file:${dbPath}` }, schema: schema_exports });
-  await migrate(db, { migrationsFolder });
-  try {
-    chmodSync(dbPath, 384);
-  } catch (err) {
-    console.error(
-      `[volute] WARNING: Failed to restrict database file permissions on ${dbPath}:`,
-      err
-    );
-  }
-  return db;
-}
-
-export {
-  getDb
-};