@knowsuchagency/fulcrum 2.17.0 → 2.17.1

package/bin/fulcrum.js

@@ -46247,7 +46247,7 @@ async function runMcpServer(urlOverride, portOverride) {
   const client = new FulcrumClient(urlOverride, portOverride);
   const server = new McpServer({
     name: "fulcrum",
-    version: "2.17.0"
+    version: "2.17.1"
   });
   registerTools(server, client);
   const transport = new StdioServerTransport;
@@ -48596,7 +48596,7 @@ var marketplace_default = `{
       "name": "fulcrum",
       "source": "./",
       "description": "Task orchestration for Claude Code",
-      "version": "2.17.0",
+      "version": "2.17.1",
       "skills": [
         "./skills/fulcrum"
       ],
@@ -49784,7 +49784,7 @@ function compareVersions(v1, v2) {
 var package_default = {
   name: "@knowsuchagency/fulcrum",
   private: true,
-  version: "2.17.0",
+  version: "2.17.1",
   description: "Harness Attention. Orchestrate Agents. Ship.",
   license: "PolyForm-Perimeter-1.0.0",
   type: "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowsuchagency/fulcrum",
-  "version": "2.17.0",
+  "version": "2.17.1",
   "description": "Harness Attention. Orchestrate Agents. Ship.",
   "license": "PolyForm-Perimeter-1.0.0",
   "repository": {

package/server/index.js

@@ -361553,289 +361553,359 @@ var require_dist20 = __commonJS((exports) => {
 });
 
 // server/services/channels/slack-channel.ts
-class SlackChannel {
-  type = "slack";
-  connectionId;
-  app = null;
-  events = null;
-  status = "disconnected";
-  reconnectTimer = null;
-  isShuttingDown = false;
-  botToken = null;
-  appToken = null;
-  constructor(connectionId) {
-    this.connectionId = connectionId;
-  }
-  async initialize(events) {
-    this.events = events;
-    this.isShuttingDown = false;
-    const settings = getSettings();
-    const slackConfig = settings.channels.slack;
-    if (!slackConfig.botToken || !slackConfig.appToken) {
-      log2.messaging.warn("Slack channel missing credentials", {
-        connectionId: this.connectionId
-      });
-      this.updateStatus("disconnected");
-      return;
+var import_bolt, SlackChannel;
+var init_slack_channel = __esm(() => {
+  init_drizzle_orm();
+  init_db2();
+  init_logger3();
+  init_settings();
+  import_bolt = __toESM(require_dist20(), 1);
+  SlackChannel = class SlackChannel {
+    type = "slack";
+    connectionId;
+    app = null;
+    events = null;
+    status = "disconnected";
+    reconnectTimer = null;
+    healthCheckTimer = null;
+    isShuttingDown = false;
+    botToken = null;
+    appToken = null;
+    static HEALTH_CHECK_INTERVAL = 5 * 60 * 1000;
+    constructor(connectionId) {
+      this.connectionId = connectionId;
+    }
+    async initialize(events) {
+      this.events = events;
+      this.isShuttingDown = false;
+      const settings = getSettings();
+      const slackConfig = settings.channels.slack;
+      if (!slackConfig.botToken || !slackConfig.appToken) {
+        log2.messaging.warn("Slack channel missing credentials", {
+          connectionId: this.connectionId
+        });
+        this.updateStatus("disconnected");
+        return;
+      }
+      this.botToken = slackConfig.botToken;
+      this.appToken = slackConfig.appToken;
+      await this.connect();
     }
-    this.botToken = slackConfig.botToken;
-    this.appToken = slackConfig.appToken;
-    await this.connect();
-  }
-  async connect() {
-    if (this.isShuttingDown || !this.botToken || !this.appToken)
-      return;
-    try {
-      this.updateStatus("connecting");
-      this.app = new import_bolt.App({
-        token: this.botToken,
-        appToken: this.appToken,
-        socketMode: true,
-        logLevel: import_bolt.LogLevel.WARN
-      });
-      this.app.command(/.*/, async ({ ack, command, respond }) => {
-        await ack();
-        await this.handleSlashCommand(command, respond);
+    async connect() {
+      if (this.isShuttingDown || !this.botToken || !this.appToken)
+        return;
+      try {
+        this.updateStatus("connecting");
+        this.app = new import_bolt.App({
+          token: this.botToken,
+          appToken: this.appToken,
+          socketMode: true,
+          logLevel: import_bolt.LogLevel.WARN
+        });
+        this.app.command(/.*/, async ({ ack, command, respond }) => {
+          await ack();
+          await this.handleSlashCommand(command, respond);
+        });
+        this.app.message(async ({ message }) => {
+          if (message.channel_type === "im") {
+            await this.handleMessage(message);
+          }
+        });
+        await this.app.start();
+        this.setupSocketModeListeners();
+        const authTest = await this.app.client.auth.test();
+        log2.messaging.info("Slack bot connected", {
+          connectionId: this.connectionId,
+          botId: authTest.bot_id,
+          userId: authTest.user_id
+        });
+        this.updateStatus("connected");
+        this.startHealthCheck();
+        const displayName = authTest.user || "Slack Bot";
+        db2.update(messagingConnections).set({
+          displayName,
+          updatedAt: new Date().toISOString()
+        }).where(eq(messagingConnections.id, this.connectionId)).run();
+        this.events?.onDisplayNameChange?.(displayName);
+      } catch (err) {
+        log2.messaging.error("Slack connect error", {
+          connectionId: this.connectionId,
+          error: String(err)
+        });
+        this.updateStatus("disconnected");
+        this.scheduleReconnect();
+      }
+    }
+    setupSocketModeListeners() {
+      const receiver2 = this.app?.receiver;
+      const socketClient = receiver2?.client;
+      if (!socketClient) {
+        log2.messaging.warn("Could not access Socket Mode client for health monitoring", {
+          connectionId: this.connectionId
+        });
+        return;
+      }
+      socketClient.on("disconnected", () => {
+        if (this.isShuttingDown)
+          return;
+        log2.messaging.warn("Slack Socket Mode disconnected", {
+          connectionId: this.connectionId
+        });
+        this.updateStatus("disconnected");
       });
-      this.app.message(async ({ message }) => {
-        if (message.channel_type === "im") {
-          await this.handleMessage(message);
-        }
+      socketClient.on("reconnecting", () => {
+        if (this.isShuttingDown)
+          return;
+        log2.messaging.info("Slack Socket Mode reconnecting", {
+          connectionId: this.connectionId
+        });
+        this.updateStatus("connecting");
       });
-      await this.app.start();
-      const authTest = await this.app.client.auth.test();
-      log2.messaging.info("Slack bot connected", {
-        connectionId: this.connectionId,
-        botId: authTest.bot_id,
-        userId: authTest.user_id
+      socketClient.on("connected", () => {
+        if (this.isShuttingDown)
+          return;
+        log2.messaging.info("Slack Socket Mode reconnected", {
+          connectionId: this.connectionId
+        });
+        this.updateStatus("connected");
       });
-      this.updateStatus("connected");
-      const displayName = authTest.user || "Slack Bot";
-      db2.update(messagingConnections).set({
-        displayName,
-        updatedAt: new Date().toISOString()
-      }).where(eq(messagingConnections.id, this.connectionId)).run();
-      this.events?.onDisplayNameChange?.(displayName);
-    } catch (err) {
-      log2.messaging.error("Slack connect error", {
-        connectionId: this.connectionId,
-        error: String(err)
+      log2.messaging.debug("Socket Mode event listeners attached", {
+        connectionId: this.connectionId
       });
-      this.updateStatus("disconnected");
-      this.scheduleReconnect();
     }
-  }
-  async handleMessage(message) {
-    if (message.bot_id || message.subtype === "bot_message")
-      return;
-    const content = message.text;
-    if (!content)
-      return;
-    const userId = message.user;
-    if (!userId)
-      return;
-    let senderName;
-    try {
-      if (this.app) {
-        const userInfo = await this.app.client.users.info({ user: userId });
-        senderName = userInfo.user?.real_name || userInfo.user?.name;
+    startHealthCheck() {
+      this.stopHealthCheck();
+      this.healthCheckTimer = setInterval(async () => {
+        if (this.isShuttingDown || !this.app || this.status !== "connected")
+          return;
+        try {
+          await this.app.client.auth.test();
+        } catch (err) {
+          log2.messaging.warn("Slack health check failed, triggering reconnect", {
+            connectionId: this.connectionId,
+            error: String(err)
+          });
+          this.updateStatus("disconnected");
+          try {
+            await this.app?.stop();
+          } catch {}
+          this.app = null;
+          this.scheduleReconnect();
+        }
+      }, SlackChannel.HEALTH_CHECK_INTERVAL);
+    }
+    stopHealthCheck() {
+      if (this.healthCheckTimer) {
+        clearInterval(this.healthCheckTimer);
+        this.healthCheckTimer = null;
       }
-    } catch {}
-    const incomingMessage = {
-      channelType: "slack",
-      connectionId: this.connectionId,
-      senderId: userId,
-      senderName,
-      content,
-      timestamp: new Date(parseFloat(message.ts) * 1000)
-    };
-    log2.messaging.info("Slack message received", {
-      connectionId: this.connectionId,
-      from: userId,
-      contentLength: content.length
-    });
-    try {
-      await this.events?.onMessage(incomingMessage);
-    } catch (err) {
-      log2.messaging.error("Error processing Slack message", {
+    }
+    async handleMessage(message) {
+      if (message.bot_id || message.subtype === "bot_message")
+        return;
+      const content = message.text;
+      if (!content)
+        return;
+      const userId = message.user;
+      if (!userId)
+        return;
+      let senderName;
+      try {
+        if (this.app) {
+          const userInfo = await this.app.client.users.info({ user: userId });
+          senderName = userInfo.user?.real_name || userInfo.user?.name;
+        }
+      } catch {}
+      const incomingMessage = {
+        channelType: "slack",
         connectionId: this.connectionId,
-        error: String(err)
+        senderId: userId,
+        senderName,
+        content,
+        timestamp: new Date(parseFloat(message.ts) * 1000)
+      };
+      log2.messaging.info("Slack message received", {
+        connectionId: this.connectionId,
+        from: userId,
+        contentLength: content.length
       });
-    }
-  }
-  async handleSlashCommand(command, respond) {
-    log2.messaging.info("Slack slash command received", {
-      connectionId: this.connectionId,
-      command: command.command,
-      userId: command.user_id,
-      userName: command.user_name
-    });
-    const incomingMessage = {
-      channelType: "slack",
-      connectionId: this.connectionId,
-      senderId: command.user_id,
-      senderName: command.user_name,
-      content: command.command,
-      timestamp: new Date,
-      metadata: {
-        isSlashCommand: true
+      try {
+        await this.events?.onMessage(incomingMessage);
+      } catch (err) {
+        log2.messaging.error("Error processing Slack message", {
+          connectionId: this.connectionId,
+          error: String(err)
+        });
       }
-    };
-    try {
-      await this.events?.onMessage(incomingMessage);
-      await respond({ text: "\u2713 Command received", response_type: "ephemeral" });
-    } catch (err) {
-      log2.messaging.error("Error processing Slack slash command", {
+    }
+    async handleSlashCommand(command, respond) {
+      log2.messaging.info("Slack slash command received", {
         connectionId: this.connectionId,
         command: command.command,
-        error: String(err)
-      });
-      await respond({
-        text: "Sorry, something went wrong processing your command.",
-        response_type: "ephemeral"
+        userId: command.user_id,
+        userName: command.user_name
       });
-    }
-  }
-  async shutdown() {
-    this.isShuttingDown = true;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.app) {
-      await this.app.stop();
-      this.app = null;
-    }
-    this.updateStatus("disconnected");
-    log2.messaging.info("Slack channel shutdown", {
-      connectionId: this.connectionId
-    });
-  }
-  async sendMessage(recipientId, content, metadata) {
-    if (!this.app || this.status !== "connected") {
-      log2.messaging.warn("Cannot send Slack message - not connected", {
+      const incomingMessage = {
+        channelType: "slack",
         connectionId: this.connectionId,
-        status: this.status
-      });
-      return false;
+        senderId: command.user_id,
+        senderName: command.user_name,
+        content: command.command,
+        timestamp: new Date,
+        metadata: {
+          isSlashCommand: true
+        }
+      };
+      try {
+        await this.events?.onMessage(incomingMessage);
+        await respond({ text: "\u2713 Command received", response_type: "ephemeral" });
+      } catch (err) {
+        log2.messaging.error("Error processing Slack slash command", {
+          connectionId: this.connectionId,
+          command: command.command,
+          error: String(err)
+        });
+        await respond({
+          text: "Sorry, something went wrong processing your command.",
+          response_type: "ephemeral"
+        });
+      }
     }
-    try {
-      const conversation = await this.app.client.conversations.open({
-        users: recipientId
+    async shutdown() {
+      this.isShuttingDown = true;
+      this.stopHealthCheck();
+      if (this.reconnectTimer) {
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+      }
+      if (this.app) {
+        await this.app.stop();
+        this.app = null;
+      }
+      this.updateStatus("disconnected");
+      log2.messaging.info("Slack channel shutdown", {
+        connectionId: this.connectionId
       });
-      const channelId = conversation.channel?.id;
-      if (!channelId) {
-        throw new Error("Failed to open DM channel");
+    }
+    async sendMessage(recipientId, content, metadata) {
+      if (!this.app || this.status !== "connected") {
+        log2.messaging.warn("Cannot send Slack message - not connected", {
+          connectionId: this.connectionId,
+          status: this.status
+        });
+        return false;
       }
-      if (content.length <= 4000) {
-        const messageOptions = {
-          channel: channelId,
-          text: content
-        };
-        if (metadata?.blocks) {
-          messageOptions.blocks = metadata.blocks;
-        } else {
-          messageOptions.mrkdwn = true;
+      try {
+        const conversation = await this.app.client.conversations.open({
+          users: recipientId
+        });
+        const channelId = conversation.channel?.id;
+        if (!channelId) {
+          throw new Error("Failed to open DM channel");
         }
-        await this.app.client.chat.postMessage(messageOptions);
-      } else {
-        const parts = this.splitMessage(content, 4000);
-        for (const part of parts) {
-          await this.app.client.chat.postMessage({
+        if (content.length <= 4000) {
+          const messageOptions = {
             channel: channelId,
-            text: part,
-            mrkdwn: true
-          });
-          await new Promise((resolve6) => setTimeout(resolve6, 100));
+            text: content
+          };
+          if (metadata?.blocks) {
+            messageOptions.blocks = metadata.blocks;
+          } else {
+            messageOptions.mrkdwn = true;
+          }
+          await this.app.client.chat.postMessage(messageOptions);
+        } else {
+          const parts = this.splitMessage(content, 4000);
+          for (const part of parts) {
+            await this.app.client.chat.postMessage({
+              channel: channelId,
+              text: part,
+              mrkdwn: true
+            });
+            await new Promise((resolve6) => setTimeout(resolve6, 100));
+          }
         }
+        log2.messaging.info("Slack message sent", {
+          connectionId: this.connectionId,
+          to: recipientId,
+          contentLength: content.length,
+          hasBlocks: !!metadata?.blocks
+        });
+        return true;
+      } catch (err) {
+        log2.messaging.error("Failed to send Slack message", {
+          connectionId: this.connectionId,
+          to: recipientId,
+          error: String(err)
+        });
+        return false;
       }
-      log2.messaging.info("Slack message sent", {
-        connectionId: this.connectionId,
-        to: recipientId,
-        contentLength: content.length,
-        hasBlocks: !!metadata?.blocks
-      });
-      return true;
-    } catch (err) {
-      log2.messaging.error("Failed to send Slack message", {
-        connectionId: this.connectionId,
-        to: recipientId,
-        error: String(err)
-      });
-      return false;
     }
-  }
-  splitMessage(content, maxLength) {
-    const parts = [];
-    let remaining = content;
-    while (remaining.length > 0) {
-      if (remaining.length <= maxLength) {
-        parts.push(remaining);
-        break;
-      }
-      let breakPoint = remaining.lastIndexOf(`
+    splitMessage(content, maxLength) {
+      const parts = [];
+      let remaining = content;
+      while (remaining.length > 0) {
+        if (remaining.length <= maxLength) {
+          parts.push(remaining);
+          break;
+        }
+        let breakPoint = remaining.lastIndexOf(`
 
 `, maxLength);
-      if (breakPoint === -1 || breakPoint < maxLength / 2) {
-        breakPoint = remaining.lastIndexOf(`
+        if (breakPoint === -1 || breakPoint < maxLength / 2) {
+          breakPoint = remaining.lastIndexOf(`
 `, maxLength);
+        }
+        if (breakPoint === -1 || breakPoint < maxLength / 2) {
+          breakPoint = remaining.lastIndexOf(" ", maxLength);
+        }
+        if (breakPoint === -1 || breakPoint < maxLength / 2) {
+          breakPoint = maxLength;
+        }
+        parts.push(remaining.slice(0, breakPoint));
+        remaining = remaining.slice(breakPoint).trimStart();
       }
-      if (breakPoint === -1 || breakPoint < maxLength / 2) {
-        breakPoint = remaining.lastIndexOf(" ", maxLength);
-      }
-      if (breakPoint === -1 || breakPoint < maxLength / 2) {
-        breakPoint = maxLength;
+      return parts;
+    }
+    getStatus() {
+      return this.status;
+    }
+    async logout() {
+      this.stopHealthCheck();
+      if (this.app) {
+        await this.app.stop();
+        this.app = null;
       }
-      parts.push(remaining.slice(0, breakPoint));
-      remaining = remaining.slice(breakPoint).trimStart();
+      this.botToken = null;
+      this.appToken = null;
+      db2.update(messagingConnections).set({
+        displayName: null,
+        status: "disconnected",
+        updatedAt: new Date().toISOString()
+      }).where(eq(messagingConnections.id, this.connectionId)).run();
+      this.updateStatus("disconnected");
     }
-    return parts;
-  }
-  getStatus() {
-    return this.status;
-  }
-  async logout() {
-    if (this.app) {
-      await this.app.stop();
-      this.app = null;
+    updateStatus(status) {
+      this.status = status;
+      db2.update(messagingConnections).set({
+        status,
+        updatedAt: new Date().toISOString()
+      }).where(eq(messagingConnections.id, this.connectionId)).run();
+      this.events?.onConnectionChange(status);
     }
-    this.botToken = null;
-    this.appToken = null;
-    db2.update(messagingConnections).set({
-      displayName: null,
-      status: "disconnected",
-      updatedAt: new Date().toISOString()
-    }).where(eq(messagingConnections.id, this.connectionId)).run();
-    this.updateStatus("disconnected");
-  }
-  updateStatus(status) {
-    this.status = status;
-    db2.update(messagingConnections).set({
-      status,
-      updatedAt: new Date().toISOString()
-    }).where(eq(messagingConnections.id, this.connectionId)).run();
-    this.events?.onConnectionChange(status);
-  }
-  scheduleReconnect() {
-    if (this.reconnectTimer || this.isShuttingDown)
-      return;
-    log2.messaging.debug("Scheduling Slack reconnect", {
-      connectionId: this.connectionId,
-      delayMs: 5000
-    });
-    this.reconnectTimer = setTimeout(() => {
-      this.reconnectTimer = null;
-      this.connect();
-    }, 5000);
-  }
-}
-var import_bolt;
-var init_slack_channel = __esm(() => {
-  init_drizzle_orm();
-  init_db2();
-  init_logger3();
-  init_settings();
-  import_bolt = __toESM(require_dist20(), 1);
+    scheduleReconnect() {
+      if (this.reconnectTimer || this.isShuttingDown)
+        return;
+      log2.messaging.debug("Scheduling Slack reconnect", {
+        connectionId: this.connectionId,
+        delayMs: 5000
+      });
+      this.reconnectTimer = setTimeout(() => {
+        this.reconnectTimer = null;
+        this.connect();
+      }, 5000);
+    }
+  };
 });
 
 // node_modules/imapflow/node_modules/pino/lib/caller.js
@@ -1260548,7 +1260618,7 @@ mcpRoutes.all("/", async (c) => {
   });
   const server = new McpServer({
     name: "fulcrum",
-    version: "2.17.0"
+    version: "2.17.1"
   });
   const client = new FulcrumClient(`http://localhost:${port}`);
   registerTools(server, client);