volute 0.26.0 → 0.27.0

package/dist/chunk-IAYBDWVG.js

@@ -0,0 +1,477 @@
+#!/usr/bin/env node
+import {
+  subscribe
+} from "./chunk-VIVMW2H2.js";
+import {
+  logger_default
+} from "./chunk-YUIHSKR6.js";
+import {
+  conversationParticipants,
+  conversationReads,
+  conversations,
+  getDb,
+  messages,
+  users
+} from "./chunk-H7OZRFJB.js";
+
+// src/lib/events/conversations.ts
+import { randomUUID } from "crypto";
+import { and, desc, eq, inArray, isNull, lt, sql } from "drizzle-orm";
+
+// src/lib/webhook.ts
+var slog = logger_default.child("webhook");
+function getWebhookUrl() {
+  return process.env.VOLUTE_WEBHOOK_URL;
+}
+function getAuthHeaders() {
+  const headers = { "Content-Type": "application/json" };
+  const secret = process.env.VOLUTE_WEBHOOK_SECRET;
+  if (secret) headers.Authorization = `Bearer ${secret}`;
+  return headers;
+}
+function fireWebhook(event) {
+  try {
+    const url = getWebhookUrl();
+    if (!url) return;
+    const payload = { ...event, timestamp: event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString() };
+    fetch(url, {
+      method: "POST",
+      headers: getAuthHeaders(),
+      body: JSON.stringify(payload)
+    }).then((res) => {
+      if (!res.ok) {
+        slog.warn(`webhook ${event.event} returned HTTP ${res.status}`);
+      }
+    }).catch((err) => {
+      slog.warn(`webhook delivery failed for ${event.event}`, logger_default.errorData(err));
+    });
+  } catch (err) {
+    slog.error(`webhook ${event.event} failed to serialize`, logger_default.errorData(err));
+  }
+}
+function initWebhook() {
+  const url = getWebhookUrl();
+  if (!url) return () => {
+  };
+  try {
+    const parsed = new URL(url);
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      slog.error(`VOLUTE_WEBHOOK_URL has unsupported protocol: ${parsed.protocol}`);
+      return () => {
+      };
+    }
+  } catch {
+    slog.error(`VOLUTE_WEBHOOK_URL is not a valid URL`);
+    return () => {
+    };
+  }
+  slog.info("webhook enabled");
+  return subscribe((event) => {
+    try {
+      fireWebhook({
+        event: event.type,
+        mind: event.mind,
+        data: { summary: event.summary, ...event.metadata },
+        timestamp: event.created_at
+      });
+    } catch (err) {
+      slog.error(`failed to fire webhook for ${event.type}`, logger_default.errorData(err));
+    }
+  });
+}
+
+// src/lib/events/conversation-events.ts
+var subscribers = /* @__PURE__ */ new Map();
+function subscribe2(conversationId, callback) {
+  let set = subscribers.get(conversationId);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    subscribers.set(conversationId, set);
+  }
+  set.add(callback);
+  return () => {
+    set.delete(callback);
+    if (set.size === 0) subscribers.delete(conversationId);
+  };
+}
+function publish(conversationId, event) {
+  const set = subscribers.get(conversationId);
+  if (!set) return;
+  for (const cb of set) {
+    try {
+      cb(event);
+    } catch (err) {
+      console.error("[conversation-events] subscriber threw:", err);
+      set.delete(cb);
+      if (set.size === 0) subscribers.delete(conversationId);
+    }
+  }
+}
+
+// src/lib/events/conversations.ts
+async function createConversation(mindName, channel, opts) {
+  const db = await getDb();
+  const id = randomUUID();
+  const type = opts?.type ?? "dm";
+  const name = opts?.name ?? null;
+  await db.transaction(async (tx) => {
+    await tx.insert(conversations).values({
+      id,
+      mind_name: mindName,
+      channel,
+      type,
+      name,
+      user_id: opts?.userId ?? null,
+      title: opts?.title ?? null
+    });
+    if (opts?.participantIds && opts.participantIds.length > 0) {
+      await tx.insert(conversationParticipants).values(
+        opts.participantIds.map((uid, i) => ({
+          conversation_id: id,
+          user_id: uid,
+          role: i === 0 ? "owner" : "member"
+        }))
+      );
+    }
+  });
+  fireWebhook({
+    event: "conversation_created",
+    mind: mindName ?? "",
+    data: { id, mindName, channel, type, name, title: opts?.title ?? null }
+  });
+  return {
+    id,
+    mind_name: mindName,
+    channel,
+    type,
+    name,
+    user_id: opts?.userId ?? null,
+    title: opts?.title ?? null,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function getOrCreateConversation(mindName, channel, opts) {
+  const db = await getDb();
+  const existing = await db.select().from(conversations).where(
+    and(
+      eq(conversations.mind_name, mindName),
+      eq(conversations.channel, channel),
+      eq(conversations.type, "dm")
+    )
+  ).orderBy(desc(conversations.updated_at)).limit(1).get();
+  if (existing) return existing;
+  return createConversation(mindName, channel, opts);
+}
+async function getConversation(id) {
+  const db = await getDb();
+  const row = await db.select().from(conversations).where(eq(conversations.id, id)).get();
+  return row ?? null;
+}
+async function addParticipant(conversationId, userId, role = "member") {
+  const db = await getDb();
+  await db.insert(conversationParticipants).values({
+    conversation_id: conversationId,
+    user_id: userId,
+    role
+  });
+}
+async function removeParticipant(conversationId, userId) {
+  const db = await getDb();
+  await db.delete(conversationParticipants).where(
+    and(
+      eq(conversationParticipants.conversation_id, conversationId),
+      eq(conversationParticipants.user_id, userId)
+    )
+  );
+}
+async function getParticipants(conversationId) {
+  const db = await getDb();
+  const rows = await db.select({
+    userId: conversationParticipants.user_id,
+    username: users.username,
+    userType: users.user_type,
+    role: conversationParticipants.role,
+    displayName: users.display_name,
+    description: users.description,
+    avatar: users.avatar
+  }).from(conversationParticipants).innerJoin(users, eq(conversationParticipants.user_id, users.id)).where(eq(conversationParticipants.conversation_id, conversationId)).all();
+  return rows;
+}
+async function isParticipant(conversationId, userId) {
+  const db = await getDb();
+  const row = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(
+    and(
+      eq(conversationParticipants.conversation_id, conversationId),
+      eq(conversationParticipants.user_id, userId)
+    )
+  ).get();
+  return row != null;
+}
+async function listConversationsForUser(userId) {
+  const db = await getDb();
+  const participantRows = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq(conversationParticipants.user_id, userId)).all();
+  if (participantRows.length === 0) return [];
+  const convIds = participantRows.map((r) => r.conversation_id);
+  return await db.select().from(conversations).where(inArray(conversations.id, convIds)).orderBy(desc(conversations.updated_at)).all();
+}
+async function isParticipantOrOwner(conversationId, userId) {
+  if (await isParticipant(conversationId, userId)) return true;
+  const db = await getDb();
+  const row = await db.select().from(conversations).where(and(eq(conversations.id, conversationId), eq(conversations.user_id, userId))).get();
+  return row != null;
+}
+async function deleteConversationForUser(id, userId) {
+  if (!await isParticipantOrOwner(id, userId)) return false;
+  await deleteConversation(id);
+  return true;
+}
+async function addMessage(conversationId, role, senderName, content) {
+  const db = await getDb();
+  const serialized = JSON.stringify(content);
+  const [result] = await db.insert(messages).values({ conversation_id: conversationId, role, sender_name: senderName, content: serialized }).returning({ id: messages.id, created_at: messages.created_at });
+  await db.update(conversations).set({ updated_at: sql`datetime('now')` }).where(eq(conversations.id, conversationId));
+  if (role === "user") {
+    const firstText = content.find((b) => b.type === "text");
+    const title = firstText ? firstText.text.slice(0, 80) : "";
+    if (title) {
+      await db.update(conversations).set({ title }).where(and(eq(conversations.id, conversationId), isNull(conversations.title)));
+    }
+  }
+  const msg = {
+    id: result.id,
+    conversation_id: conversationId,
+    role,
+    sender_name: senderName,
+    content,
+    created_at: result.created_at
+  };
+  publish(conversationId, {
+    type: "message",
+    id: msg.id,
+    role: msg.role,
+    senderName: msg.sender_name,
+    content: msg.content,
+    createdAt: msg.created_at
+  });
+  const conv = await db.select({ mind_name: conversations.mind_name }).from(conversations).where(eq(conversations.id, conversationId)).get();
+  fireWebhook({
+    event: "message_created",
+    mind: conv?.mind_name ?? "",
+    data: {
+      conversationId,
+      messageId: result.id,
+      role,
+      senderName,
+      content: content.filter((b) => b.type !== "image"),
+      createdAt: result.created_at
+    }
+  });
+  return msg;
+}
+async function getMessages(conversationId) {
+  const db = await getDb();
+  const rows = await db.select().from(messages).where(eq(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
+  return rows.map(parseMessageRow);
+}
+async function getMessagesPaginated(conversationId, opts) {
+  const db = await getDb();
+  const limit = Math.min(Math.max(opts?.limit ?? 50, 1), 100);
+  const conditions = [eq(messages.conversation_id, conversationId)];
+  if (opts?.before != null) {
+    conditions.push(lt(messages.id, opts.before));
+  }
+  const rows = await db.select().from(messages).where(and(...conditions)).orderBy(desc(messages.id)).limit(limit + 1).all();
+  const hasMore = rows.length > limit;
+  const page = rows.slice(0, limit).reverse();
+  return {
+    messages: page.map(parseMessageRow),
+    hasMore
+  };
+}
+function parseMessageRow(row) {
+  let content;
+  try {
+    const parsed = JSON.parse(row.content);
+    content = Array.isArray(parsed) ? parsed : [{ type: "text", text: row.content }];
+  } catch {
+    content = [{ type: "text", text: row.content }];
+  }
+  return { ...row, role: row.role, content };
+}
+async function listConversationsWithParticipants(userId) {
+  const convs = await listConversationsForUser(userId);
+  if (convs.length === 0) return [];
+  const db = await getDb();
+  const convIds = convs.map((c) => c.id);
+  const rows = await db.select({
+    conversationId: conversationParticipants.conversation_id,
+    userId: users.id,
+    username: users.username,
+    userType: users.user_type,
+    role: conversationParticipants.role,
+    displayName: users.display_name,
+    description: users.description,
+    avatar: users.avatar
+  }).from(conversationParticipants).innerJoin(users, eq(conversationParticipants.user_id, users.id)).where(inArray(conversationParticipants.conversation_id, convIds));
+  const byConv = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    let arr = byConv.get(r.conversationId);
+    if (!arr) {
+      arr = [];
+      byConv.set(r.conversationId, arr);
+    }
+    arr.push({
+      userId: r.userId,
+      username: r.username,
+      userType: r.userType,
+      role: r.role,
+      displayName: r.displayName,
+      description: r.description,
+      avatar: r.avatar
+    });
+  }
+  const lastMsgIds = await db.select({
+    conversationId: messages.conversation_id,
+    maxId: sql`MAX(${messages.id})`
+  }).from(messages).where(inArray(messages.conversation_id, convIds)).groupBy(messages.conversation_id);
+  const byLastMsg = /* @__PURE__ */ new Map();
+  if (lastMsgIds.length > 0) {
+    const msgRows = await db.select().from(messages).where(
+      inArray(
+        messages.id,
+        lastMsgIds.map((r) => r.maxId)
+      )
+    );
+    for (const m of msgRows) {
+      let text = "";
+      try {
+        const parsed = JSON.parse(m.content);
+        const blocks = Array.isArray(parsed) ? parsed : [];
+        const textBlock = blocks.find((b) => b.type === "text");
+        if (textBlock && "text" in textBlock) text = textBlock.text;
+      } catch {
+        text = m.content;
+      }
+      byLastMsg.set(m.conversation_id, {
+        role: m.role,
+        senderName: m.sender_name,
+        text,
+        createdAt: m.created_at
+      });
+    }
+  }
+  return convs.map((c) => ({
+    ...c,
+    participants: byConv.get(c.id) ?? [],
+    lastMessage: byLastMsg.get(c.id)
+  }));
+}
+async function findDMConversation(mindName, participantIds) {
+  const db = await getDb();
+  const mindConvs = await db.select({ id: conversations.id }).from(conversations).where(and(eq(conversations.mind_name, mindName), eq(conversations.type, "dm"))).all();
+  for (const conv of mindConvs) {
+    const rows = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(eq(conversationParticipants.conversation_id, conv.id)).all();
+    if (rows.length !== 2) continue;
+    const ids = new Set(rows.map((r) => r.user_id));
+    if (ids.has(participantIds[0]) && ids.has(participantIds[1])) {
+      return conv.id;
+    }
+  }
+  return null;
+}
+async function deleteConversation(id) {
+  const db = await getDb();
+  await db.delete(conversations).where(eq(conversations.id, id));
+}
+async function createChannel(name, creatorId) {
+  const participantIds = creatorId ? [creatorId] : [];
+  return createConversation(null, "volute", {
+    type: "channel",
+    name,
+    title: name,
+    participantIds
+  });
+}
+async function getChannelByName(name) {
+  const db = await getDb();
+  const row = await db.select().from(conversations).where(and(eq(conversations.name, name), eq(conversations.type, "channel"))).get();
+  return row ?? null;
+}
+async function listChannels() {
+  const db = await getDb();
+  return await db.select().from(conversations).where(eq(conversations.type, "channel")).orderBy(conversations.name).all();
+}
+async function joinChannel(conversationId, userId) {
+  if (await isParticipant(conversationId, userId)) return;
+  await addParticipant(conversationId, userId);
+}
+async function leaveChannel(conversationId, userId) {
+  await removeParticipant(conversationId, userId);
+}
+async function getUnreadCounts(userId, conversationIds) {
+  if (conversationIds.length === 0) return {};
+  const db = await getDb();
+  const rows = await db.select({
+    conversationId: messages.conversation_id,
+    count: sql`COUNT(*)`
+  }).from(messages).leftJoin(
+    conversationReads,
+    and(
+      eq(conversationReads.conversation_id, messages.conversation_id),
+      eq(conversationReads.user_id, userId)
+    )
+  ).where(
+    and(
+      inArray(messages.conversation_id, conversationIds),
+      sql`${messages.id} > COALESCE(${conversationReads.last_read_message_id}, 0)`
+    )
+  ).groupBy(messages.conversation_id);
+  const result = {};
+  for (const row of rows) {
+    result[row.conversationId] = row.count;
+  }
+  return result;
+}
+async function markConversationRead(userId, conversationId) {
+  const db = await getDb();
+  const maxRow = await db.select({ maxId: sql`MAX(${messages.id})` }).from(messages).where(eq(messages.conversation_id, conversationId)).get();
+  const maxId = maxRow?.maxId ?? 0;
+  if (maxId === 0) return;
+  await db.insert(conversationReads).values({ user_id: userId, conversation_id: conversationId, last_read_message_id: maxId }).onConflictDoUpdate({
+    target: [conversationReads.user_id, conversationReads.conversation_id],
+    set: { last_read_message_id: maxId }
+  });
+}
+
+export {
+  getWebhookUrl,
+  getAuthHeaders,
+  fireWebhook,
+  initWebhook,
+  subscribe2 as subscribe,
+  publish,
+  createConversation,
+  getOrCreateConversation,
+  getConversation,
+  addParticipant,
+  removeParticipant,
+  getParticipants,
+  isParticipant,
+  listConversationsForUser,
+  isParticipantOrOwner,
+  deleteConversationForUser,
+  addMessage,
+  getMessages,
+  getMessagesPaginated,
+  listConversationsWithParticipants,
+  findDMConversation,
+  deleteConversation,
+  createChannel,
+  getChannelByName,
+  listChannels,
+  joinChannel,
+  leaveChannel,
+  getUnreadCounts,
+  markConversationRead
+};

package/dist/{chunk-TZKJLDQN.js → chunk-IKRVFPWU.js}

@@ -1,27 +1,30 @@
 #!/usr/bin/env node
 import {
-  voluteHome
-} from "./chunk-B2CPS4QU.js";
+  voluteHome,
+  voluteSystemDir
+} from "./chunk-H7OZRFJB.js";
 
 // src/lib/setup.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { resolve } from "path";
 function configPath() {
-  return resolve(voluteHome(), "config.json");
+  return resolve(voluteSystemDir(), "config.json");
 }
 function readGlobalConfig() {
   const path = configPath();
-  if (!existsSync(path)) return {};
+  const legacyPath = resolve(voluteHome(), "config.json");
+  const effectivePath = existsSync(path) ? path : legacyPath;
+  if (!existsSync(effectivePath)) return {};
   try {
-    return JSON.parse(readFileSync(path, "utf-8"));
+    return JSON.parse(readFileSync(effectivePath, "utf-8"));
   } catch (err) {
-    console.error(`Failed to parse ${path}: ${err instanceof Error ? err.message : err}`);
+    console.error(`Failed to parse ${effectivePath}: ${err instanceof Error ? err.message : err}`);
     return {};
   }
 }
 function writeGlobalConfig(config) {
   const path = configPath();
-  mkdirSync(voluteHome(), { recursive: true });
+  mkdirSync(voluteSystemDir(), { recursive: true });
   writeFileSync(path, JSON.stringify(config, null, 2) + "\n");
 }
 function isSetupComplete() {
@@ -32,8 +35,10 @@ function migrateSetupConfig() {
   const config = readGlobalConfig();
   if (config.setup) return;
   const home = voluteHome();
-  const registryPath = resolve(home, "minds.json");
-  if (!existsSync(registryPath)) return;
+  const systemDir = voluteSystemDir();
+  const registryPath = resolve(systemDir, "minds.json");
+  const legacyRegistryPath = resolve(home, "minds.json");
+  if (!existsSync(registryPath) && !existsSync(legacyRegistryPath)) return;
   const isSystem = process.env.VOLUTE_ISOLATION === "user";
   const mindsDir = process.env.VOLUTE_MINDS_DIR || resolve(home, "minds");
   let hasService = false;

package/dist/{chunk-WGOGUMPO.js → chunk-JGFVMROS.js}

@@ -1,13 +1,15 @@
 #!/usr/bin/env node
 import {
-  voluteHome
-} from "./chunk-B2CPS4QU.js";
+  voluteHome,
+  voluteSystemDir,
+  voluteUserHome
+} from "./chunk-H7OZRFJB.js";
 
 // src/lib/daemon-client.ts
 import { existsSync, readFileSync } from "fs";
 import { resolve } from "path";
 function readCliSession() {
-  const sessionPath = resolve(voluteHome(), "cli-session.json");
+  const sessionPath = resolve(voluteUserHome(), "cli-session.json");
   if (!existsSync(sessionPath)) return null;
   try {
     return JSON.parse(readFileSync(sessionPath, "utf-8"));
@@ -16,7 +18,9 @@ function readCliSession() {
   }
 }
 function readDaemonConfig() {
-  const configPath = resolve(voluteHome(), "daemon.json");
+  const newPath = resolve(voluteSystemDir(), "daemon.json");
+  const legacyPath = resolve(voluteHome(), "daemon.json");
+  const configPath = existsSync(newPath) ? newPath : legacyPath;
   if (!existsSync(configPath)) {
     if (existsSync("/etc/systemd/system/volute.service") && !process.env.VOLUTE_HOME) {
       console.error("Volute is running as a system service but VOLUTE_HOME is not set.");
@@ -56,8 +60,11 @@ async function daemonFetch(path, options) {
   const config = readDaemonConfig();
   const url = buildUrl(config);
   const headers = new Headers(options?.headers);
-  const cliSession = readCliSession();
-  if (cliSession?.sessionId) {
+  const daemonToken = process.env.VOLUTE_DAEMON_TOKEN;
+  const cliSession = daemonToken ? null : readCliSession();
+  if (daemonToken) {
+    headers.set("Authorization", `Bearer ${daemonToken}`);
+  } else if (cliSession?.sessionId) {
     headers.set("Authorization", `Bearer ${cliSession.sessionId}`);
   }
   headers.set("Origin", url);

package/dist/{chunk-3TV4GLFO.js → chunk-JKOWNZ4P.js}

@@ -4,14 +4,14 @@ import {
 } from "./chunk-YUIHSKR6.js";
 import {
   gitExec
-} from "./chunk-YJA7P64S.js";
+} from "./chunk-AW7PFDVN.js";
 import {
   isIsolationEnabled,
   mindUserName
-} from "./chunk-XOXLRRR2.js";
+} from "./chunk-RKQEHRBB.js";
 import {
   voluteHome
-} from "./chunk-B2CPS4QU.js";
+} from "./chunk-H7OZRFJB.js";
 
 // src/lib/shared.ts
 import { execFileSync } from "child_process";

package/dist/{chunk-NWI2425I.js → chunk-K5NAC55T.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   publish
-} from "./chunk-J2CO4WEV.js";
+} from "./chunk-VIVMW2H2.js";
 import {
   logger_default
 } from "./chunk-YUIHSKR6.js";

package/dist/{chunk-HFCBO2GL.js → chunk-KDGS53OS.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
-  voluteHome
-} from "./chunk-B2CPS4QU.js";
+  voluteUserHome
+} from "./chunk-H7OZRFJB.js";
 
 // src/lib/systems-config.ts
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { resolve } from "path";
 var DEFAULT_API_URL = "https://volute.systems";
 function configPath() {
-  return resolve(voluteHome(), "systems.json");
+  return resolve(voluteUserHome(), "systems.json");
 }
 function readSystemsConfig() {
   const path = configPath();
@@ -29,7 +29,7 @@ function readSystemsConfig() {
   };
 }
 function writeSystemsConfig(config) {
-  mkdirSync(voluteHome(), { recursive: true });
+  mkdirSync(voluteUserHome(), { recursive: true });
   writeFileSync(configPath(), `${JSON.stringify(config, null, 2)}
 `, { mode: 384 });
 }

package/dist/chunk-KTLFDYPT.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+// src/connectors/bridge-sdk.ts
+function loadBridgeEnv() {
+  const daemonUrl = process.env.VOLUTE_DAEMON_URL;
+  const daemonToken = process.env.VOLUTE_DAEMON_TOKEN;
+  const platform = process.env.VOLUTE_BRIDGE_PLATFORM;
+  if (!daemonUrl || !daemonToken || !platform) {
+    console.error(
+      "Missing required env vars: VOLUTE_DAEMON_URL, VOLUTE_DAEMON_TOKEN, VOLUTE_BRIDGE_PLATFORM"
+    );
+    process.exit(1);
+  }
+  return { daemonUrl, daemonToken, platform };
+}
+function getHeaders(env) {
+  return {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${env.daemonToken}`,
+    Origin: env.daemonUrl
+  };
+}
+async function sendToBridge(env, message) {
+  const url = `${env.daemonUrl}/api/bridges/${env.platform}/inbound`;
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: getHeaders(env),
+      body: JSON.stringify(message)
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      console.error(`Bridge inbound returned ${res.status}: ${body}`);
+      return { ok: false, error: `Bridge returned ${res.status}` };
+    }
+    return await res.json();
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to send bridge message: ${detail}`);
+    return { ok: false, error: `Failed to reach daemon: ${detail}` };
+  }
+}
+function onShutdown(cleanup) {
+  const handler = () => {
+    Promise.resolve(cleanup()).then(
+      () => process.exit(0),
+      (err) => {
+        console.error(`Shutdown error: ${err}`);
+        process.exit(1);
+      }
+    );
+  };
+  process.on("SIGINT", handler);
+  process.on("SIGTERM", handler);
+}
+
+export {
+  loadBridgeEnv,
+  sendToBridge,
+  onShutdown
+};