@chrysb/alphaclaw 0.8.3-beta.0 → 0.8.3-beta.2

package/lib/public/js/components/routes/chat-route.js

@@ -1,13 +1,13 @@
-import { h } from "https://esm.sh/preact";
+import { h } from "preact";
 import {
   useCallback,
   useEffect,
   useMemo,
   useRef,
   useState,
-} from "https://esm.sh/preact/hooks";
-import htm from "https://esm.sh/htm";
-import { marked } from "https://esm.sh/marked";
+} from "preact/hooks";
+import htm from "htm";
+import { marked } from "marked";
 import { authFetch } from "../../lib/api.js";
 import { kChatSessionDraftsStorageKey } from "../../lib/storage-keys.js";
 import { showToast } from "../toast.js";

package/lib/public/js/hooks/use-browse-navigation.js

@@ -56,12 +56,13 @@ export const useBrowseNavigation = ({
     location,
   });
 
+  // Derive sidebar tab only from `location`. Avoid optimistic setSidebarTab + this effect
+  // fighting (e.g. chat tab selected while hash is still /general → pane never mounts).
   useEffect(() => {
-    setSidebarTab((currentTab) => {
+    setSidebarTab(() => {
       if (location.startsWith("/browse")) return "browse";
       if (location.startsWith("/chat")) return "chat";
-      if (currentTab === "browse" || currentTab === "chat") return "menu";
-      return currentTab;
+      return "menu";
     });
   }, [location]);
 
@@ -148,7 +149,6 @@ export const useBrowseNavigation = ({
   }, [browsePreviewPath, onCloseMobileSidebar, selectedBrowsePath, setLocation]);
 
   const handleSelectSidebarTab = useCallback((nextTab) => {
-    setSidebarTab(nextTab);
     if (nextTab === "menu" && location.startsWith("/browse")) {
       setBrowsePreviewPath("");
       setLocation(lastMenuRoute || `/${kDefaultUiTab}`);

package/lib/server/chat-ws.js

@@ -7,7 +7,15 @@ const kConnectTimeoutMs = 8000;
 const kHistoryTimeoutMs = 12000;
 const kGatewayReqTimeoutMs = 15000;
 const kGatewayProtocolVersion = 3;
-const kGatewayAdminScopes = ["operator.admin"];
+// Gateway method auth (see OpenClaw method-scopes): chat.history needs operator.read;
+// chat.send / chat.abort need operator.write. Align with CLI_DEFAULT_OPERATOR_SCOPES plus admin.
+const kGatewayChatBridgeScopes = [
+  "operator.admin",
+  "operator.read",
+  "operator.write",
+  "operator.approvals",
+  "operator.pairing",
+];
 
 const collectHistoryTextFragments = (value) => {
   if (typeof value === "string") {
@@ -252,9 +260,35 @@ const resolveSessionKeyFromPayload = (payload = {}) =>
 
 const sanitizeError = (error) => {
   const message = error instanceof Error ? error.message : String(error || "");
-  if (message.toLowerCase().includes("not connected")) {
+  const lower = message.toLowerCase();
+  console.error(`[alphaclaw] chat websocket handler error: ${message}`);
+  if (lower.includes("not connected")) {
     return "Agent runtime is not connected right now.";
   }
+  if (
+    lower.includes("gateway is not connected") ||
+    lower.includes("econnrefused") ||
+    lower.includes("connect failed")
+  ) {
+    return "Could not connect to the OpenClaw gateway. Check that the gateway is running and reachable.";
+  }
+  if (lower.includes("timed out") || lower.includes("timeout")) {
+    return "The gateway did not respond in time. Try again after the gateway finishes starting.";
+  }
+  if (
+    lower.includes("auth") ||
+    lower.includes("token") ||
+    lower.includes("unauthorized") ||
+    lower.includes("forbidden")
+  ) {
+    return "Gateway authentication failed. Verify OPENCLAW_GATEWAY_TOKEN matches the gateway.";
+  }
+  if (lower.includes("method not found") || lower.includes("unknown method")) {
+    return "This gateway build does not support chat APIs. Update OpenClaw.";
+  }
+  if (lower.includes("gateway request failed")) {
+    return "The gateway could not start this chat run. Check gateway logs.";
+  }
   return "Something went wrong. Please try again.";
 };
 
@@ -522,7 +556,7 @@ const createChatWsService = ({
               mode: "backend",
             },
             role: "operator",
-            scopes: kGatewayAdminScopes,
+            scopes: kGatewayChatBridgeScopes,
             caps: [],
             commands: [],
             permissions: {},
@@ -733,9 +767,12 @@ const createChatWsService = ({
         }
       };
       run().catch((err) => {
+        const sessionKey = String(payload?.sessionKey || "").trim();
         sendJson(ws, {
           type: "error",
           message: sanitizeError(err),
+          ...(sessionKey ? { sessionKey } : {}),
+          messageId: crypto.randomUUID(),
         });
       });
     });

package/lib/server/constants.js

@@ -135,6 +135,8 @@ const kFallbackOnboardingModels = [
 
 const kVersionCacheTtlMs = 60 * 1000;
 const kLatestVersionCacheTtlMs = 10 * 60 * 1000;
+/** `cp` of a full openclaw npm tree into /app/node_modules can exceed 60s on slow volumes. */
+const kOpenclawUpdateCopyTimeoutMs = 5 * 60 * 1000;
 const kOpenclawRegistryUrl = "https://registry.npmjs.org/openclaw";
 const kAlphaclawRegistryUrl = "https://registry.npmjs.org/@chrysb%2falphaclaw";
 const kAlphaclawGithubReleasesBaseUrl =
@@ -370,6 +372,7 @@ const SETUP_API_PREFIXES = [
   "/api/codex",
   "/api/models",
   "/api/browse",
+  "/api/chat",
   "/api/gateway",
   "/api/restart-status",
   "/api/onboard",
@@ -425,6 +428,7 @@ module.exports = {
   kFallbackOnboardingModels,
   kVersionCacheTtlMs,
   kLatestVersionCacheTtlMs,
+  kOpenclawUpdateCopyTimeoutMs,
   kOpenclawRegistryUrl,
   kAlphaclawRegistryUrl,
   kAlphaclawGithubReleasesBaseUrl,

package/lib/server/openclaw-version.js

@@ -6,6 +6,7 @@ const {
   kVersionCacheTtlMs,
   kLatestVersionCacheTtlMs,
   kNpmPackageRoot,
+  kOpenclawUpdateCopyTimeoutMs,
 } = require("./constants");
 const { normalizeOpenclawVersion } = require("./helpers");
 const { parseJsonObjectFromNoisyOutput } = require("./utils/json");
@@ -174,7 +175,7 @@ const createOpenclawVersionService = ({
           const dest = path.join(installDir, "node_modules");
           exec(
             `cp -af "${src}/." "${dest}/"`,
-            { timeout: 60000 },
+            { timeout: kOpenclawUpdateCopyTimeoutMs },
             (cpErr) => {
               cleanup();
               if (cpErr) {

package/lib/server/routes/proxy.js

@@ -29,8 +29,8 @@ const registerProxyRoutes = ({
   app.all(kHooksPathPattern, webhookMiddleware);
   app.all(kWebhookPathPattern, webhookMiddleware);
 
-  app.all(kApiPathPattern, (req, res) => {
-    if (SETUP_API_PREFIXES.some((p) => req.path.startsWith(p))) return;
+  app.all(kApiPathPattern, (req, res, next) => {
+    if (SETUP_API_PREFIXES.some((p) => req.path.startsWith(p))) return next();
     proxy.web(req, res, { target: getGatewayUrl() });
   });
 };

package/lib/server/slack-api.js

@@ -1,5 +1,15 @@
 const kSlackApiBase = "https://slack.com/api";
+const fs = require("fs");
+const { Readable } = require("stream");
+const { Blob } = require("buffer");
 
+/**
+ * Create Slack API client with enhanced features:
+ * - Threading support
+ * - Reactions
+ * - File uploads
+ * - Backward compatible with existing code
+ */
 const createSlackApi = (getToken) => {
   const call = async (method, body = {}) => {
     const token = typeof getToken === "function" ? getToken() : getToken;
@@ -24,14 +34,213 @@ const createSlackApi = (getToken) => {
     return data;
   };
 
+  /**
+   * Convert various file input types to Buffer
+   */
+  const toBuffer = async (content) => {
+    if (Buffer.isBuffer(content)) {
+      return content;
+    } else if (content instanceof Readable) {
+      const chunks = [];
+      for await (const chunk of content) {
+        chunks.push(chunk);
+      }
+      return Buffer.concat(chunks);
+    } else if (typeof content === "string" && fs.existsSync(content)) {
+      return fs.readFileSync(content);
+    } else {
+      throw new Error("Invalid file content: must be Buffer, Stream, or file path");
+    }
+  };
+
+  /**
+   * Verify Slack credentials
+   */
   const authTest = () => call("auth.test");
 
-  const postMessage = (channel, text) =>
-    call("chat.postMessage", { channel, text: String(text || "") });
+  /**
+   * Send a message to a channel or DM
+   * @param {string} channel - Channel ID or user ID
+   * @param {string} text - Message text
+   * @param {object} opts - Options
+   * @param {string} opts.thread_ts - Thread timestamp (for threaded replies)
+   * @param {boolean} opts.reply_broadcast - Also send to channel (when in thread)
+   * @param {boolean} opts.mrkdwn - Enable Slack markdown formatting (default: true)
+   * @returns {Promise<object>} Response with ts (message timestamp)
+   */
+  const postMessage = (channel, text, opts = {}) => {
+    const payload = {
+      channel,
+      text: String(text || ""),
+    };
+
+    // Threading support
+    if (opts.thread_ts) {
+      payload.thread_ts = opts.thread_ts;
+    }
+    if (opts.reply_broadcast) {
+      payload.reply_broadcast = true;
+    }
+
+    // Formatting
+    if (opts.mrkdwn !== false) {
+      payload.mrkdwn = true;
+    }
+
+    return call("chat.postMessage", payload);
+  };
+
+  /**
+   * Post a message in a thread (convenience wrapper)
+   * @param {string} channel - Channel ID
+   * @param {string} threadTs - Thread timestamp
+   * @param {string} text - Message text
+   * @param {object} opts - Additional options (reply_broadcast, etc.)
+   */
+  const postMessageInThread = (channel, threadTs, text, opts = {}) => {
+    return postMessage(channel, text, { ...opts, thread_ts: threadTs });
+  };
+
+  /**
+   * Add a reaction emoji to a message
+   * @param {string} channel - Channel ID
+   * @param {string} timestamp - Message timestamp
+   * @param {string} emoji - Emoji name (without colons, e.g., "white_check_mark")
+   */
+  const addReaction = (channel, timestamp, emoji) => {
+    // Remove colons if user included them
+    const cleanEmoji = String(emoji || "").replace(/^:|:$/g, "");
+    return call("reactions.add", {
+      channel,
+      timestamp,
+      name: cleanEmoji,
+    });
+  };
+
+  /**
+   * Remove a reaction emoji from a message
+   * @param {string} channel - Channel ID
+   * @param {string} timestamp - Message timestamp
+   * @param {string} emoji - Emoji name (without colons)
+   */
+  const removeReaction = (channel, timestamp, emoji) => {
+    const cleanEmoji = String(emoji || "").replace(/^:|:$/g, "");
+    return call("reactions.remove", {
+      channel,
+      timestamp,
+      name: cleanEmoji,
+    });
+  };
+
+  /**
+   * Upload a file to Slack using the 3-step external upload flow
+   * @param {string|string[]} channels - Channel ID(s) to share file in
+   * @param {Buffer|Stream|string} fileContent - File content (Buffer, Stream, or file path)
+   * @param {object} opts - Options
+   * @param {string} opts.filename - Filename
+   * @param {string} opts.title - File title
+   * @param {string} opts.initial_comment - Comment to add with file
+   * @param {string} opts.thread_ts - Thread timestamp (upload to thread)
+   * @param {string} opts.contentType - MIME type
+   * @returns {Promise<object>} Upload response with file info
+   */
+  const uploadFile = async (channels, fileContent, opts = {}) => {
+    const filename = opts.filename || "file";
+    const buffer = await toBuffer(fileContent);
+    const filesize = buffer.length;
+
+    // Step 1: Get upload URL
+    const uploadInfo = await call("files.getUploadURLExternal", {
+      filename,
+      length: filesize,
+    });
+
+    const { upload_url, file_id } = uploadInfo;
+
+    // Step 2: Upload file to the external URL (raw POST, no auth)
+    const uploadRes = await fetch(upload_url, {
+      method: "POST",
+      headers: {
+        "Content-Type": opts.contentType || "application/octet-stream",
+      },
+      body: buffer,
+    });
+
+    if (!uploadRes.ok) {
+      throw new Error(`File upload to external URL failed: HTTP ${uploadRes.status}`);
+    }
+
+    // Step 3: Complete the upload and share to channel(s)
+    const completePayload = {
+      files: [
+        {
+          id: file_id,
+          title: opts.title || filename,
+        },
+      ],
+    };
+
+    // Handle single channel vs multiple channels
+    if (channels) {
+      if (Array.isArray(channels)) {
+        completePayload.channel_id = channels[0]; // Primary channel
+        if (channels.length > 1) {
+          throw new Error("Multi-channel upload not supported with external upload flow. Use channel_id for one channel.");
+        }
+      } else {
+        completePayload.channel_id = channels;
+      }
+    }
+
+    if (opts.initial_comment) {
+      completePayload.initial_comment = opts.initial_comment;
+    }
+
+    if (opts.thread_ts) {
+      completePayload.thread_ts = opts.thread_ts;
+    }
+
+    return call("files.completeUploadExternal", completePayload);
+  };
+
+  /**
+   * Upload text as a code snippet with syntax highlighting
+   * @param {string|string[]} channels - Channel ID(s)
+   * @param {string} content - Text content
+   * @param {object} opts - Options
+   * @param {string} opts.filename - Filename (affects syntax highlighting, e.g., "code.js")
+   * @param {string} opts.title - Snippet title
+   * @param {string} opts.filetype - File type for syntax highlighting (e.g., "javascript")
+   * @param {string} opts.initial_comment - Comment
+   * @param {string} opts.thread_ts - Thread timestamp
+   */
+  const uploadTextSnippet = (channels, content, opts = {}) => {
+    const buffer = Buffer.from(String(content || ""), "utf8");
+    
+    // Detect language from filename if provided
+    let filename = opts.filename || "snippet.txt";
+    if (opts.filetype) {
+      const ext = opts.filetype.replace(/^\./, "");
+      if (!filename.includes(".")) {
+        filename = `snippet.${ext}`;
+      }
+    }
+
+    return uploadFile(channels, buffer, {
+      ...opts,
+      filename,
+      contentType: "text/plain",
+    });
+  };
 
   return {
     authTest,
     postMessage,
+    postMessageInThread,
+    addReaction,
+    removeReaction,
+    uploadFile,
+    uploadTextSnippet,
   };
 };
 

package/lib/server/watchdog-notify.js

@@ -36,8 +36,14 @@ const getPairedIds = (channel) => {
 const formatDiscordMessage = (message) =>
   String(message || "").replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "**$1**");
 
+/**
+ * Track thread state for Slack notifications
+ * Key: userId, Value: { threadTs, lastEvent }
+ */
+const slackThreads = new Map();
+
 const createWatchdogNotifier = ({ telegramApi, discordApi, slackApi }) => {
-  const notify = async (message) => {
+  const notify = async (message, opts = {}) => {
     const summary = {
       telegram: { sent: 0, failed: 0, skipped: false, targets: 0 },
       discord: { sent: 0, failed: 0, skipped: false, targets: 0 },
@@ -78,14 +84,58 @@ const createWatchdogNotifier = ({ telegramApi, discordApi, slackApi }) => {
       }
     }
 
+    // Enhanced Slack notifications with threading and reactions
     const slackTargets = getPairedIds("slack");
     summary.slack.targets = slackTargets.length;
     if (!slackApi?.postMessage || !process.env.SLACK_BOT_TOKEN || slackTargets.length === 0) {
       summary.slack.skipped = true;
     } else {
+      const eventType = opts.eventType || "info"; // crash, recovery, health, info
+      
       for (const userId of slackTargets) {
         try {
-          await slackApi.postMessage(userId, String(message || ""));
+          let threadTs = null;
+          let shouldCreateNewThread = true;
+
+          // Check if we have an active thread for this user
+          const existingThread = slackThreads.get(userId);
+          if (existingThread && existingThread.lastEvent === "crash" && eventType === "recovery") {
+            // Recovery message goes in the crash thread
+            threadTs = existingThread.threadTs;
+            shouldCreateNewThread = false;
+          }
+
+          // Send message (in thread if continuing conversation)
+          const result = await slackApi.postMessage(userId, String(message || ""), {
+            thread_ts: threadTs,
+            mrkdwn: true,
+          });
+
+          // Store thread for future related messages
+          if (shouldCreateNewThread && result.ts) {
+            slackThreads.set(userId, {
+              threadTs: result.ts,
+              lastEvent: eventType,
+            });
+          }
+
+          // Add reactions based on event type
+          // Use result.channel (the actual conversation/DM ID) instead of userId
+          if (result.ts && result.channel && slackApi.addReaction) {
+            try {
+              if (eventType === "crash") {
+                await slackApi.addReaction(result.channel, result.ts, "x");
+              } else if (eventType === "recovery") {
+                await slackApi.addReaction(result.channel, result.ts, "white_check_mark");
+              } else if (eventType === "health") {
+                await slackApi.addReaction(result.channel, result.ts, "heart");
+              }
+            } catch (reactionErr) {
+              // Reactions are nice-to-have, don't fail the whole notification
+              console.error(`[watchdog] slack reaction failed for ${userId}: ${reactionErr.message}`);
+            }
+          }
+
           summary.slack.sent += 1;
         } catch (err) {
           summary.slack.failed += 1;

package/lib/server/watchdog.js

@@ -184,12 +184,12 @@ const createWatchdog = ({
     }
   };
 
-  const notify = async (message, correlationId = "") => {
+  const notify = async (message, correlationId = "", eventType = "info") => {
     if (state.notificationsDisabled) {
       return { ok: false, skipped: true, reason: "notifications_disabled" };
     }
     if (!notifier?.notify) return { ok: false, reason: "notifier_unavailable" };
-    const result = await notifier.notify(message);
+    const result = await notifier.notify(message, { eventType });
     logEvent(
       "notification",
       "watchdog",
@@ -204,9 +204,10 @@ const createWatchdog = ({
     notificationKey,
     message,
     correlationId = "",
+    eventType = "info",
   ) => {
     const key = String(notificationKey || "").trim();
-    if (!key) return notify(message, correlationId);
+    if (!key) return notify(message, correlationId, eventType);
     if (sentIncidentNotifications.has(key)) {
       return {
         ok: false,
@@ -214,7 +215,7 @@ const createWatchdog = ({
         reason: "incident_notification_already_sent",
       };
     }
-    const result = await notify(message, correlationId);
+    const result = await notify(message, correlationId, eventType);
     if (result?.ok || result?.skipped) {
       sentIncidentNotifications.add(key);
     }
@@ -273,6 +274,7 @@ const createWatchdog = ({
         ...(attempts > 0 ? [`Attempt count: ${attempts}`] : []),
       ].join("\n"),
       correlationId,
+      ok && verifiedHealthy ? "recovery" : "crash",
     );
   };
 
@@ -468,6 +470,7 @@ const createWatchdog = ({
             withViewLogsSuffix("Auto-repair paused until manual action."),
           ].join("\n"),
           correlationId,
+          "crash",
         );
       }
       return { ok: false, result };
@@ -543,6 +546,7 @@ const createWatchdog = ({
             withViewLogsSuffix("🟢 Gateway healthy again"),
           ].join("\n"),
           correlationId,
+          "recovery",
         );
       }
       state.pendingRecoveryNoticeSource = "";
@@ -766,6 +770,7 @@ const createWatchdog = ({
             : ["Auto-restart paused; manual action required."]),
         ].join("\n"),
         correlationId,
+        "crash",
       );
       if (state.autoRepair) {
         void runRepair({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.8.3-beta.0",
+  "version": "0.8.3-beta.2",
   "publishConfig": {
     "access": "public"
   },
@@ -19,11 +19,13 @@
   },
   "files": [
     "bin/",
-    "lib/"
+    "lib/",
+    "patches/"
   ],
   "scripts": {
     "start": "node bin/alphaclaw.js start",
     "build:ui": "node scripts/build-ui.mjs",
+    "postinstall": "patch-package",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:watchdog": "vitest run tests/server/watchdog.test.js tests/server/watchdog-db.test.js tests/server/routes-watchdog.test.js",
@@ -33,13 +35,14 @@
   "dependencies": {
     "express": "^4.21.0",
     "http-proxy": "^1.18.1",
-    "openclaw": "2026.3.13",
+    "openclaw": "^2026.3.28",
+    "patch-package": "^8.0.1",
     "ws": "^8.19.0"
   },
   "devDependencies": {
+    "@vitest/coverage-v8": "^4.0.18",
     "@xterm/addon-fit": "^0.10.0",
     "@xterm/xterm": "^5.5.0",
-    "@vitest/coverage-v8": "^4.0.18",
     "chart.js": "^4.5.1",
     "esbuild": "^0.25.9",
     "htm": "^3.1.1",
@@ -51,6 +54,6 @@
     "wouter-preact": "^3.7.1"
   },
   "engines": {
-    "node": ">=22.12.0"
+    "node": ">=22.14.0"
   }
 }

package/patches/openclaw+2026.3.28.patch

@@ -0,0 +1,13 @@
+diff --git a/node_modules/openclaw/dist/gateway-cli-DlnlX7IW.js b/node_modules/openclaw/dist/gateway-cli-DlnlX7IW.js
+index ca48b932..c12478c4 100644
+--- a/node_modules/openclaw/dist/gateway-cli-DlnlX7IW.js
++++ b/node_modules/openclaw/dist/gateway-cli-DlnlX7IW.js
+@@ -25935,7 +25935,7 @@ function attachGatewayWsMessageHandler(params) {
+ 					close(1008, truncateCloseReason(authMessage));
+ 				};
+ 				const clearUnboundScopes = () => {
+-					if (scopes.length > 0) {
++					if (scopes.length > 0 && !sharedAuthOk) {
+ 						scopes = [];
+ 						connectParams.scopes = scopes;
+ 					}