@chrysb/alphaclaw 0.9.5 → 0.9.7

package/lib/public/js/components/modal-shell.js

@@ -1,5 +1,5 @@
 import { h } from "preact";
-import { useEffect } from "preact/hooks";
+import { useEffect, useRef } from "preact/hooks";
 import { createPortal } from "preact/compat";
 import htm from "htm";
 
@@ -13,6 +13,8 @@ export const ModalShell = ({
   panelClassName = "bg-modal border border-border rounded-xl p-5 max-w-md w-full space-y-3",
   children = null,
 }) => {
+  const overlayPointerDownRef = useRef(false);
+
   useEffect(() => {
     if (!visible || !closeOnEscape) return;
 
@@ -30,8 +32,22 @@ export const ModalShell = ({
     html`
       <div
         class="fixed inset-0 bg-overlay flex items-start justify-center overflow-y-auto p-4 sm:items-center z-50"
+        onpointerdown=${(event) => {
+          overlayPointerDownRef.current = event.target === event.currentTarget;
+        }}
+        onpointerup=${(event) => {
+          const shouldClose =
+            closeOnOverlayClick &&
+            overlayPointerDownRef.current &&
+            event.target === event.currentTarget;
+          overlayPointerDownRef.current = false;
+          if (shouldClose) onClose?.();
+        }}
+        onpointercancel=${() => {
+          overlayPointerDownRef.current = false;
+        }}
         onclick=${(event) => {
-          if (closeOnOverlayClick && event.target === event.currentTarget) onClose?.();
+          event.preventDefault();
         }}
       >
         <div class=${panelClassName}>${children}</div>

package/lib/public/js/components/onboarding/welcome-pairing-step.js

@@ -14,6 +14,14 @@ const kChannelMeta = {
     label: "Discord",
     iconSrc: "/assets/icons/discord.svg",
   },
+  slack: {
+    label: "Slack",
+    iconSrc: "/assets/icons/slack.svg",
+  },
+  whatsapp: {
+    label: "WhatsApp",
+    iconSrc: "/assets/icons/whatsapp.svg",
+  },
 };
 
 const PairingRow = ({ pairing, onApprove, onReject }) => {
@@ -79,7 +87,6 @@ const PairingRow = ({ pairing, onApprove, onReject }) => {
 export const WelcomePairingStep = ({
   channel,
   pairings,
-  channels,
   loading,
   error,
   onApprove,
@@ -94,15 +101,13 @@ export const WelcomePairingStep = ({
       : "Channel",
     iconSrc: "",
   };
-  const channelInfo = channels?.[channel];
 
   if (!channel) {
     return html`
       <div
         class="bg-status-error-bg border border-status-error-border rounded-xl p-3 text-status-error text-sm"
       >
-        Missing channel configuration. Go back and add a Telegram or Discord bot
-        token.
+        Missing channel configuration. Go back and add a channel credential.
       </div>
     `;
   }
@@ -116,8 +121,8 @@ export const WelcomePairingStep = ({
               🎉 Setup complete
             </p>
             <p class="text-xs text-body">
-              Your ${channelMeta.label} channel is connected. You can switch
-              to ${channelMeta.label} and start using your agent now.
+              Your ${channelMeta.label} channel is connected. You can switch to${" "}
+              ${channelMeta.label} and start using your agent now.
             </p>
             <p class="text-xs text-fg-muted font-normal opacity-85">
               Continue to the dashboard to explore extras like Google Workspace

package/lib/public/js/components/pairings.js

@@ -62,7 +62,7 @@ export const PairingRow = ({ p, onApprove, onReject }) => {
     </div>`;
 };
 
-const ALL_CHANNELS = ['telegram', 'discord', 'slack'];
+const ALL_CHANNELS = ['telegram', 'discord', 'slack', 'whatsapp'];
 
 const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
 

package/lib/public/js/components/welcome/index.js

@@ -66,7 +66,6 @@ export const Welcome = ({ onComplete, acVersion }) => {
                   ? html`<${WelcomePairingStep}
                       channel=${state.selectedPairingChannel}
                       pairings=${state.pairingRequestsPoll.data || []}
-                      channels=${state.pairingChannels}
                       loading=${!state.pairingStatusPoll.data}
                       error=${state.pairingError}
                       onApprove=${actions.handlePairingApprove}

package/lib/public/js/components/welcome/use-welcome.js

@@ -334,7 +334,7 @@ export const useWelcome = ({ onComplete }) => {
       const pairingChannel = getPreferredPairingChannel(normalizedVals);
       if (!pairingChannel) {
         throw new Error(
-          "No Telegram or Discord bot token configured for pairing.",
+          "No channel credential configured for pairing.",
         );
       }
       setVals((prev) => ({

package/lib/public/js/lib/api.js

@@ -982,6 +982,29 @@ export const deleteChannelAccount = async (payload) => {
   return parseJsonOrThrow(res, "Could not delete channel account");
 };
 
+export const runChannelAccountLogin = async (payload) => {
+  const res = await authFetch("/api/channels/accounts/login", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload || {}),
+  });
+  return parseJsonOrThrow(res, "Could not run channel login");
+};
+
+export const fetchChannelAccountLoginStatus = async ({
+  provider = "",
+  accountId = "default",
+} = {}) => {
+  const params = new URLSearchParams({
+    provider: String(provider || ""),
+    accountId: String(accountId || "default"),
+  });
+  const res = await authFetch(
+    `/api/channels/accounts/login-status?${params.toString()}`,
+  );
+  return parseJsonOrThrow(res, "Could not load channel login status");
+};
+
 export const fetchAgent = async (agentId) => {
   const res = await authFetch(`/api/agents/${encodeURIComponent(String(agentId || ""))}`);
   return parseJsonOrThrow(res, "Could not load agent");

package/lib/public/js/lib/channel-provider-availability.js

@@ -1,4 +1,4 @@
-const kSingleAccountChannelProviders = new Set(["discord"]);
+const kSingleAccountChannelProviders = new Set(["discord", "whatsapp"]);
 
 const hasConfiguredAccounts = ({ configuredChannelMap, provider }) => {
   const channelEntry = configuredChannelMap instanceof Map

package/lib/server/agents/channels.js

@@ -18,6 +18,7 @@ const {
   deriveChannelExtraEnvKeys,
   getConfiguredChannelEnvKeys,
   assertActiveChannelTokenEnvVars,
+  hasSavedWhatsAppCredentials,
   normalizeChannelConfig,
   appendBindingToConfig,
   buildBindingSpec,
@@ -101,8 +102,6 @@ const createChannelsDomain = ({
       const provider = normalizeChannelProvider(input.provider);
       const name =
         String(input.name || "").trim() || kChannelLabels[provider] || provider;
-      const token = String(input.token || "").trim();
-      if (!token) throw new Error("Channel token is required");
 
       const cfg = withNormalizedAgentsConfig({
         OPENCLAW_DIR,
@@ -143,12 +142,31 @@ const createChannelsDomain = ({
           `Channel account "${provider}/${accountId}" already exists`,
         );
       }
-      if (provider === "discord" && Object.keys(existingAccounts).length > 0) {
+      if (
+        (provider === "discord" || provider === "whatsapp") &&
+        Object.keys(existingAccounts).length > 0
+      ) {
         throw new Error(
           `${kChannelLabels[provider] || "This provider"} supports a single channel account`,
         );
       }
 
+      if (provider === "whatsapp") {
+        return await createWhatsAppChannelAccount({
+          input,
+          cfg,
+          agentId,
+          accountId,
+          name,
+          normalizedChannelConfig,
+          existingAccounts,
+          onProgress,
+        });
+      }
+
+      const token = String(input.token || "").trim();
+      if (!token) throw new Error("Channel token is required");
+
       const envKey = deriveChannelEnvKey({ provider, accountId });
       const extraEnvKeys = deriveChannelExtraEnvKeys({ provider, accountId });
       const appToken = String(input.appToken || "").trim();
@@ -157,7 +175,9 @@ const createChannelsDomain = ({
       }
       const tokenField = kChannelTokenFields[provider];
       const currentEnvVars = readEnvFile();
-      const previousEnvVars = Array.isArray(currentEnvVars) ? currentEnvVars : [];
+      const previousEnvVars = Array.isArray(currentEnvVars)
+        ? currentEnvVars
+        : [];
       const duplicateEnvEntry = previousEnvVars.find((entry) => {
         const existingKey = String(entry?.key || "").trim();
         const existingValue = String(entry?.value || "").trim();
@@ -555,6 +575,53 @@ const createChannelsDomain = ({
     }
   };
 
+  const cleanupWhatsAppAuthFiles = ({ accountId }) => {
+    const credDir = resolveCredentialsDirPath({ OPENCLAW_DIR });
+    const providerCredDir = path.join(credDir, "whatsapp");
+    const normalizedAccountId =
+      String(accountId || "")
+        .trim()
+        .toLowerCase() || "default";
+
+    try {
+      fsImpl.rmSync(path.join(credDir, "whatsapp", normalizedAccountId), {
+        recursive: true,
+        force: true,
+      });
+    } catch {}
+
+    try {
+      fsImpl.rmSync(providerCredDir, {
+        recursive: true,
+        force: true,
+      });
+    } catch {}
+
+    if (normalizedAccountId !== "default") {
+      return;
+    }
+
+    const legacyAuthPatterns = [
+      "creds.json",
+      "creds.json.bak",
+    ];
+    try {
+      const entries = fsImpl.readdirSync(credDir);
+      for (const entry of Array.isArray(entries) ? entries : []) {
+        const fileName = String(entry || "").trim();
+        if (!fileName) continue;
+        if (
+          legacyAuthPatterns.includes(fileName) ||
+          /^(app-state-sync|session|sender-key|pre-key)-.*\.json$/.test(fileName)
+        ) {
+          try {
+            fsImpl.rmSync(path.join(credDir, fileName), { force: true });
+          } catch {}
+        }
+      }
+    } catch {}
+  };
+
   const deleteChannelAccount = async (input = {}) => {
     const provider = normalizeChannelProvider(input.provider);
     const accountId = String(input.accountId || "").trim() || "default";
@@ -731,9 +798,21 @@ const createChannelsDomain = ({
       if (hasScopedFields) return true;
       return !matchesBinding(match, targetMatch);
     });
+    if (!nextChannels[provider] && nextCfg.plugins?.entries?.[provider]) {
+      nextCfg.plugins.entries[provider] = {
+        ...(nextCfg.plugins.entries[provider] || {}),
+        enabled: false,
+      };
+    }
     saveConfig({ fsImpl, OPENCLAW_DIR, config: nextCfg });
 
     cleanupChannelAccountPairingFiles({ provider, accountId });
+    if (provider === "whatsapp") {
+      cleanupWhatsAppAuthFiles({ accountId });
+    }
+    if (provider === "whatsapp") {
+      await restartGateway();
+    }
     return { ok: true };
   };
 
@@ -763,11 +842,196 @@ const createChannelsDomain = ({
     }));
   };
 
+  const createWhatsAppChannelAccount = async ({
+    input,
+    cfg,
+    agentId,
+    accountId,
+    name,
+    normalizedChannelConfig,
+    existingAccounts,
+    onProgress,
+  }) => {
+    const ownerNumber = String(input.token || "").trim();
+    if (!ownerNumber) throw new Error("WhatsApp owner number is required");
+
+    const envKey = deriveChannelEnvKey({ provider: "whatsapp", accountId });
+    const currentEnvVars = readEnvFile();
+    const previousEnvVars = Array.isArray(currentEnvVars) ? currentEnvVars : [];
+    const previousConfig = cloneJson(cfg);
+
+    const nextEnvVars = previousEnvVars.filter(
+      (entry) => String(entry?.key || "").trim() !== envKey,
+    );
+    nextEnvVars.push({ key: envKey, value: ownerNumber });
+
+    try {
+      onProgress({ phase: "configuring", label: "Configuring..." });
+      writeEnvFile(nextEnvVars);
+      reloadEnv();
+
+      const nextCfg = withNormalizedAgentsConfig({
+        OPENCLAW_DIR,
+        cfg: loadConfig({ fsImpl, OPENCLAW_DIR }),
+      });
+      ensurePluginAllowed({ cfg: nextCfg, pluginKey: "whatsapp" });
+      saveConfig({ fsImpl, OPENCLAW_DIR, config: nextCfg });
+
+      onProgress({ phase: "configuring", label: "Adding channel..." });
+      const addArgs = [
+        "channels add",
+        "--channel whatsapp",
+        accountId !== "default" ? `--account ${shellEscapeArg(accountId)}` : "",
+        name ? `--name ${shellEscapeArg(name)}` : "",
+        `--token ${shellEscapeArg(ownerNumber)}`,
+      ].filter(Boolean);
+      const addResult = await clawCmd(addArgs.join(" "), {
+        quiet: true,
+        timeoutMs: 30000,
+      });
+      if (!addResult?.ok) {
+        throw new Error(
+          addResult?.stderr ||
+            addResult?.stdout ||
+            "Could not add WhatsApp channel account",
+        );
+      }
+
+      const refreshedCfg = withNormalizedAgentsConfig({
+        OPENCLAW_DIR,
+        cfg: loadConfig({ fsImpl, OPENCLAW_DIR }),
+      });
+
+      const nextAccounts = { ...existingAccounts };
+      nextAccounts[accountId] = {
+        ...(nextAccounts[accountId] &&
+        typeof nextAccounts[accountId] === "object"
+          ? nextAccounts[accountId]
+          : {}),
+        ...(name ? { name } : {}),
+        allowFrom: [`\${${envKey}}`],
+        groupAllowFrom: [`\${${envKey}}`],
+        dmPolicy: "allowlist",
+        groupPolicy: "allowlist",
+        selfChatMode: true,
+      };
+      normalizedChannelConfig.accounts = nextAccounts;
+      normalizedChannelConfig.enabled = true;
+      if (!String(normalizedChannelConfig.defaultAccount || "").trim()) {
+        normalizedChannelConfig.defaultAccount = "default";
+      }
+      refreshedCfg.channels =
+        refreshedCfg.channels && typeof refreshedCfg.channels === "object"
+          ? { ...refreshedCfg.channels }
+          : {};
+      refreshedCfg.channels.whatsapp = normalizedChannelConfig;
+
+      const bindSpec = buildBindingSpec({ provider: "whatsapp", accountId });
+      appendBindingToConfig({
+        cfg: refreshedCfg,
+        agentId,
+        match: normalizeBindingMatch({ channel: "whatsapp", accountId }),
+      });
+      saveConfig({ fsImpl, OPENCLAW_DIR, config: refreshedCfg });
+
+      onProgress({ phase: "restarting", label: "Rebooting..." });
+      await restartGateway();
+    } catch (error) {
+      try {
+        await clawCmd(
+          [
+            "channels remove",
+            "--channel whatsapp",
+            accountId !== "default" ? `--account ${shellEscapeArg(accountId)}` : "",
+            "--delete",
+          ]
+            .filter(Boolean)
+            .join(" "),
+          { quiet: true, timeoutMs: 30000 },
+        );
+      } catch {}
+      try {
+        writeEnvFile(previousEnvVars);
+        reloadEnv();
+      } catch {}
+      try {
+        saveConfig({ fsImpl, OPENCLAW_DIR, config: previousConfig });
+      } catch {}
+      throw error;
+    }
+
+    return {
+      channel: "whatsapp",
+      account: { id: accountId, name, envKey },
+      binding: {
+        agentId,
+        match: normalizeBindingMatch({ channel: "whatsapp", accountId }),
+      },
+      restartRequired: true,
+    };
+  };
+
+  const runChannelAccountLogin = async ({
+    provider: rawProvider,
+    accountId: rawAccountId,
+  } = {}) => {
+    const provider = normalizeChannelProvider(rawProvider);
+    if (provider !== "whatsapp") {
+      throw new Error("Channel login is currently only supported for WhatsApp");
+    }
+    const accountId = String(rawAccountId || "").trim() || "default";
+    const loginArgs = [
+      "channels login",
+      `--channel ${shellEscapeArg(provider)}`,
+      accountId !== "default" ? `--account ${shellEscapeArg(accountId)}` : "",
+    ].filter(Boolean);
+    const loginStartedAt = Date.now();
+    const result = await clawCmd(loginArgs.join(" "), {
+      quiet: true,
+      timeoutMs: 12000,
+      killSignal: "SIGKILL",
+    });
+    const elapsedMs = Date.now() - loginStartedAt;
+    console.log(
+      `[channels] login ${provider}/${accountId} finished ok=${!!result?.ok} code=${String(
+        result?.code ?? "",
+      )} elapsedMs=${elapsedMs}`,
+    );
+    return {
+      ok: !!result?.ok,
+      stdout: String(result?.stdout || ""),
+      stderr: String(result?.stderr || ""),
+      completed: !!result?.ok,
+    };
+  };
+
+  const getChannelAccountLoginStatus = ({
+    provider: rawProvider,
+    accountId: rawAccountId,
+  } = {}) => {
+    const provider = normalizeChannelProvider(rawProvider);
+    if (provider !== "whatsapp") {
+      throw new Error("Channel login status is currently only supported for WhatsApp");
+    }
+    const accountId = String(rawAccountId || "").trim() || "default";
+    return {
+      provider,
+      accountId,
+      linked: hasSavedWhatsAppCredentials({
+        fsImpl,
+        OPENCLAW_DIR,
+        accountId,
+      }),
+    };
+  };
+
   return {
     getChannelAccountToken,
     createChannelAccount,
     updateChannelAccount,
     deleteChannelAccount,
+    runChannelAccountLogin,
+    getChannelAccountLoginStatus,
     listConfiguredChannelAccountsWithMaskedTokens,
   };
 };

package/lib/server/agents/service.js

@@ -41,6 +41,8 @@ const createAgentsService = ({
     createChannelAccount: channelsDomain.createChannelAccount,
     updateChannelAccount: channelsDomain.updateChannelAccount,
     deleteChannelAccount: channelsDomain.deleteChannelAccount,
+    runChannelAccountLogin: channelsDomain.runChannelAccountLogin,
+    getChannelAccountLoginStatus: channelsDomain.getChannelAccountLoginStatus,
     listConfiguredChannelAccounts:
       channelsDomain.listConfiguredChannelAccountsWithMaskedTokens,
   };