@chrysb/alphaclaw 0.5.3 → 0.5.4-beta.0

package/lib/public/js/hooks/use-destination-session-selection.js

@@ -0,0 +1,85 @@
+import { useCallback, useEffect, useMemo, useState } from "https://esm.sh/preact/hooks";
+import { useAgentSessions } from "./useAgentSessions.js";
+
+export const kNoDestinationSessionValue = "__none__";
+
+export const kDestinationSessionFilter = (sessionRow) => {
+  const key = String(sessionRow?.key || "").toLowerCase();
+  return key.includes(":direct:") || key.includes(":group:");
+};
+
+export const getDestinationFromSession = (sessionRow = null) => {
+  const channel = String(sessionRow?.replyChannel || "").trim();
+  const to = String(sessionRow?.replyTo || "").trim();
+  if (!channel || !to) return null;
+  return { channel, to };
+};
+
+export const useDestinationSessionSelection = ({
+  enabled = false,
+  resetKey = "",
+} = {}) => {
+  const [manualSessionKey, setManualSessionKey] = useState("");
+  const [hasManualSelection, setHasManualSelection] = useState(false);
+  const {
+    sessions,
+    selectedSessionKey,
+    setSelectedSessionKey,
+    loading,
+    error,
+  } = useAgentSessions({
+    enabled,
+    filter: kDestinationSessionFilter,
+  });
+
+  useEffect(() => {
+    if (!enabled) return;
+    setManualSessionKey("");
+    setHasManualSelection(false);
+  }, [enabled, resetKey]);
+
+  const preferredSessionKey = useMemo(() => {
+    const matchingPreferredSession = sessions.find(
+      (sessionRow) =>
+        String(sessionRow?.key || "") === String(selectedSessionKey || "").trim(),
+    );
+    return String(
+      matchingPreferredSession?.key || sessions[0]?.key || "",
+    ).trim();
+  }, [sessions, selectedSessionKey]);
+
+  const effectiveSessionKey = hasManualSelection
+    ? manualSessionKey
+    : preferredSessionKey;
+
+  const selectedSession = useMemo(
+    () =>
+      sessions.find(
+        (sessionRow) =>
+          String(sessionRow?.key || "") === String(effectiveSessionKey || "").trim(),
+      ) || null,
+    [effectiveSessionKey, sessions],
+  );
+
+  const selectedDestination = useMemo(
+    () => getDestinationFromSession(selectedSession),
+    [selectedSession],
+  );
+
+  const setDestinationSessionKey = useCallback((key) => {
+    const normalizedKey = String(key || "");
+    setManualSessionKey(normalizedKey);
+    setHasManualSelection(true);
+    setSelectedSessionKey(normalizedKey);
+  }, [setSelectedSessionKey]);
+
+  return {
+    sessions,
+    loading,
+    error,
+    destinationSessionKey: effectiveSessionKey,
+    setDestinationSessionKey,
+    selectedDestinationSession: selectedSession,
+    selectedDestination,
+  };
+};

package/lib/public/js/hooks/useAgentSessions.js

@@ -119,6 +119,20 @@ export const useAgentSessions = ({ enabled = false, filter } = {}) => {
     [allSessions, filter],
   );
 
+  useEffect(() => {
+    if (!enabled) return;
+    if (sessions.length === 0) {
+      if (selectedSessionKey) setSelectedSessionKeyState("");
+      return;
+    }
+    const hasSelectedSession = sessions.some(
+      (row) => String(row?.key || "") === String(selectedSessionKey || ""),
+    );
+    if (hasSelectedSession) return;
+    const preferred = pickPreferredSession(sessions, readLastSessionKey());
+    setSelectedSessionKeyState(String(preferred?.key || ""));
+  }, [enabled, sessions, selectedSessionKey]);
+
   const selectedSession = useMemo(
     () => sessions.find((row) => String(row?.key || "") === selectedSessionKey) || null,
     [sessions, selectedSessionKey],

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

@@ -163,11 +163,14 @@ export const saveGmailConfig = async ({
   return parseJsonOrThrow(res, "Could not save Gmail watch config");
 };
 
-export const startGmailWatch = async (accountId) => {
+export const startGmailWatch = async (accountId, { destination = null } = {}) => {
   const res = await authFetch("/api/gmail/watch/start", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ accountId: String(accountId || "") }),
+    body: JSON.stringify({
+      accountId: String(accountId || ""),
+      ...(destination ? { destination } : {}),
+    }),
   });
   return parseJsonOrThrow(res, "Could not start Gmail watch");
 };
@@ -655,11 +658,14 @@ export async function fetchWebhookDetail(name) {
   return parseJsonOrThrow(res, "Could not load webhook detail");
 }
 
-export async function createWebhook(name) {
+export async function createWebhook(name, { destination = null } = {}) {
   const res = await authFetch("/api/webhooks", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ name }),
+    body: JSON.stringify({
+      name,
+      ...(destination ? { destination } : {}),
+    }),
   });
   return parseJsonOrThrow(res, "Could not create webhook");
 }

package/lib/public/js/lib/clipboard.js

@@ -0,0 +1,40 @@
+export const copyTextToClipboard = async (value) => {
+  const text = String(value || "");
+  if (!text) return false;
+
+  try {
+    if (navigator?.clipboard?.writeText) {
+      await navigator.clipboard.writeText(text);
+      return true;
+    }
+  } catch {}
+
+  let fallbackElement = null;
+  let appendedFallbackElement = false;
+  try {
+    if (
+      !document?.createElement ||
+      !document?.body?.appendChild ||
+      !document?.body?.removeChild ||
+      typeof document.execCommand !== "function"
+    ) {
+      return false;
+    }
+
+    fallbackElement = document.createElement("textarea");
+    fallbackElement.value = text;
+    fallbackElement.setAttribute("readonly", "");
+    fallbackElement.style.position = "fixed";
+    fallbackElement.style.opacity = "0";
+    document.body.appendChild(fallbackElement);
+    appendedFallbackElement = true;
+    fallbackElement.select();
+    return document.execCommand("copy");
+  } catch {
+    return false;
+  } finally {
+    if (fallbackElement && appendedFallbackElement) {
+      document.body.removeChild(fallbackElement);
+    }
+  }
+};

package/lib/public/js/lib/model-config.js

@@ -22,8 +22,8 @@ export const kFeaturedModelDefs = [
     preferredKeys: ["openai-codex/gpt-5.3-codex", "openai-codex/gpt-5.2-codex"],
   },
   {
-    label: "Gemini 3",
-    preferredKeys: ["google/gemini-3-pro-preview", "google/gemini-3-flash-preview"],
+    label: "Gemini 3.1 Pro",
+    preferredKeys: ["google/gemini-3.1-pro-preview", "google/gemini-3-flash-preview"],
   },
 ];
 

package/lib/server/auth-profiles.js

@@ -41,6 +41,8 @@ const credentialMode = (credential) => {
 const getEnvVarForApiKeyProvider = (provider) =>
   kApiKeyEnvVarByProvider[String(provider || "").trim()] || "";
 
+const listApiKeyProviders = () => Object.keys(kApiKeyEnvVarByProvider);
+
 const getDefaultProfileIdForApiKeyProvider = (provider) => {
   const normalized = String(provider || "").trim();
   return normalized ? `${normalized}:default` : "";
@@ -339,6 +341,7 @@ const createAuthProfiles = () => {
     upsertApiKeyProfileForEnvVar,
     removeApiKeyProfileForEnvVar,
     getEnvVarForApiKeyProvider,
+    listApiKeyProviders,
     getDefaultProfileIdForApiKeyProvider,
     getModelConfig,
     setModelConfig,

package/lib/server/constants.js

@@ -118,9 +118,9 @@ const kFallbackOnboardingModels = [
     label: "OpenAI GPT-5.1 Codex",
   },
   {
-    key: "google/gemini-3-pro-preview",
+    key: "google/gemini-3.1-pro-preview",
     provider: "google",
-    label: "Gemini 3 Pro Preview",
+    label: "Gemini 3.1 Pro",
   },
   {
     key: "google/gemini-3-flash-preview",

package/lib/server/db/usage/pricing.js

@@ -13,7 +13,7 @@ const kGlobalModelPricing = {
   "gpt-4.1": { input: 2.0, output: 8.0 },
   "gpt-4o": { input: 2.5, output: 10.0 },
   "gpt-4o-mini": { input: 0.15, output: 0.6 },
-  "gemini-3-pro-preview": { input: 2.0, output: 12.0 },
+  "gemini-3.1-pro-preview": { input: 2.0, output: 12.0 },
   "gemini-3-flash-preview": { input: 0.5, output: 3.0 },
   "gemini-2.0-flash": { input: 0.1, output: 0.4 },
 };

package/lib/server/doctor/prompt.js

@@ -12,17 +12,37 @@ const renderList = (items = []) =>
 const renderContextFileList = (files = []) =>
   files.map((file) => `\`${file.path}\``).join(", ");
 
-const renderResolvedCards = (cards = []) => {
+const renderHistoricalCards = (cards = []) => {
   if (!cards.length) return "";
-  const lines = cards.map(
-    (card) =>
-      `- [${card.status}] ${card.title}` +
-      (card.category ? ` (${card.category})` : ""),
-  );
+  const dismissedLines = cards
+    .filter((card) => card?.status === "dismissed")
+    .map(
+      (card) =>
+        `- [${card.status}] ${card.title}` +
+        (card.category ? ` (${card.category})` : ""),
+    );
+  const fixedLines = cards
+    .filter((card) => card?.status === "fixed")
+    .map(
+      (card) =>
+        `- [${card.status}] ${card.title}` +
+        (card.category ? ` (${card.category})` : ""),
+    );
+  const sections = [];
+  if (dismissedLines.length) {
+    sections.push(
+      `Previously dismissed findings (do not re-suggest these):\n${dismissedLines.join("\n")}`,
+    );
+  }
+  if (fixedLines.length) {
+    sections.push(
+      `Previou findings marked as fixed (context only; re-suggest them if they are still present):\n${fixedLines.join("\n")}`,
+    );
+  }
+  if (!sections.length) return "";
   return `
 
-Previously resolved findings (do not re-suggest these):
-${lines.join("\n")}
+${sections.join("\n\n")}
 `;
 };
 
@@ -115,13 +135,15 @@ Return exactly this JSON shape:
   ]
 }
 
-${renderResolvedCards(resolvedCards)}Constraints:
+${renderHistoricalCards(resolvedCards)}Constraints:
 - Maximum 12 cards
 - Use relative paths in evidence and targetPaths
 - Include startLine (and optionally endLine) in evidence and targetPaths when the finding relates to a specific section of a file
 - targetPaths items can be strings or objects with { path, startLine? }
 - Do not include duplicate cards
-- Do not re-suggest findings that appear in the "Previously resolved" list above
+- Do not re-suggest findings that appear in the "Previously dismissed" list above
+- Previously fixed findings may be re-suggested if the underlying issue is still present
+- If a previously fixed finding is still present, you may call that out in the summary or card wording
 - Do not create cards for healthy default-template behavior
 - Do not create cards whose primary recommendation is to refactor AlphaClaw-managed file structure
 - fixPrompt must only reference files the agent can edit. Never suggest editing files listed in "AlphaClaw locked/managed paths" above — they are managed by AlphaClaw, so manual edits would be lost.

package/lib/server/gmail-watch.js

@@ -61,6 +61,47 @@ const parseProjectIdFromTopicPath = (topicPath = "") => {
   return match?.[1] ? String(match[1]) : "";
 };
 
+const normalizeDestination = (destination = null) => {
+  if (!destination || typeof destination !== "object") return null;
+  const channel = String(destination?.channel || "").trim();
+  const to = String(destination?.to || "").trim();
+  if (!channel && !to) return null;
+  if (!channel || !to) {
+    throw new Error("destination.channel and destination.to are required");
+  }
+  return { channel, to };
+};
+
+const buildGmailTransformSource = (destination = null) => {
+  const normalizedDestination = normalizeDestination(destination);
+  return [
+    "export default async function transform(payload) {",
+    "  const data = payload?.payload || payload || {};",
+    "  const messages = Array.isArray(data.messages) ? data.messages : [];",
+    "  const first = messages[0] || {};",
+    "  const from = String(first.from || \"unknown sender\").trim();",
+    "  const subject = String(first.subject || \"(no subject)\").trim();",
+    "  const snippet = String(first.snippet || \"\").trim();",
+    "  return {",
+    "    message: `New email from ${from}\\nSubject: ${subject}\\n${snippet}`.trim(),",
+    "    messages,",
+    '    name: "Gmail",',
+    '    wakeMode: "now",',
+    ...(normalizedDestination
+      ? [
+          `    channel: ${JSON.stringify(normalizedDestination.channel)},`,
+          `    to: ${JSON.stringify(normalizedDestination.to)},`,
+        ]
+      : []),
+    "  };",
+    "}",
+    "",
+  ].join("\n");
+};
+
+const getGmailTransformAbsolutePath = (constants) =>
+  path.join(constants.OPENCLAW_DIR, "hooks/transforms/gmail/gmail-transform.mjs");
+
 const ensureTopicPathForClient = ({
   state,
   client,
@@ -209,7 +250,7 @@ const createGmailWatchService = ({
     return { token, changed: true };
   };
 
-  const ensureHooksPreset = () => {
+  const ensureHooksPreset = ({ destination = null } = {}) => {
     const configPath = path.join(constants.OPENCLAW_DIR, "openclaw.json");
     if (!fs.existsSync(configPath)) {
       throw new Error("openclaw.json not found. Complete onboarding first.");
@@ -253,23 +294,7 @@ const createGmailWatchService = ({
         wakeMode: "now",
         transform: { module: gmailTransformModulePath },
       },
-      transformSource: [
-        "export default async function transform(payload) {",
-        "  const data = payload?.payload || payload || {};",
-        "  const messages = Array.isArray(data.messages) ? data.messages : [];",
-        "  const first = messages[0] || {};",
-        "  const from = String(first.from || \"unknown sender\").trim();",
-        "  const subject = String(first.subject || \"(no subject)\").trim();",
-        "  const snippet = String(first.snippet || \"\").trim();",
-        "  return {",
-        "    message: `New email from ${from}\\nSubject: ${subject}\\n${snippet}`.trim(),",
-        "    messages,",
-        '    name: "Gmail",',
-        '    wakeMode: "now",',
-        "  };",
-        "}",
-        "",
-      ].join("\n"),
+      transformSource: buildGmailTransformSource(destination),
     });
     const webhookAfter = fs.readFileSync(configPath, "utf8");
     if (webhookBefore !== webhookAfter) {
@@ -278,9 +303,9 @@ const createGmailWatchService = ({
     return { changed };
   };
 
-  const ensureHookWiring = () => {
+  const ensureHookWiring = ({ destination = null } = {}) => {
     const webhook = ensureWebhookToken();
-    const hooks = ensureHooksPreset();
+    const hooks = ensureHooksPreset({ destination });
     const changed = webhook.changed || hooks.changed;
     if (changed) markRestartRequired("gmail-watch");
     return { webhookToken: webhook.token, changed };
@@ -341,6 +366,7 @@ const createGmailWatchService = ({
     const pushEndpoint = `${baseUrl}/gmail-pubsub?token=${encodeURIComponent(
       String(push.token || ""),
     )}`;
+    const transformExists = fs.existsSync(getGmailTransformAbsolutePath(constants));
     const commands =
       projectId && push.token
         ? {
@@ -358,6 +384,7 @@ const createGmailWatchService = ({
       subscriptionName,
       pushEndpoint,
       commands,
+      transformExists,
       configured: Boolean(topicPath && push.token && projectId),
     };
   };
@@ -448,7 +475,7 @@ const createGmailWatchService = ({
     };
   };
 
-  const startWatch = async ({ accountId, req }) => {
+  const startWatch = async ({ accountId, req, destination = null }) => {
     let state = readState();
     const account = getGoogleAccountById(state, accountId);
     if (!account) throw new Error("Google account not found");
@@ -466,7 +493,7 @@ const createGmailWatchService = ({
     state = ensuredTopic.state;
     const topicPath = ensuredTopic.topicPath;
 
-    const { webhookToken } = ensureHookWiring();
+    const { webhookToken } = ensureHookWiring({ destination });
     const watchStart = await runGogForAccount({
       account,
       command:

package/lib/server/onboarding/github.js

@@ -109,7 +109,7 @@ const verifyGithubRepoForOnboarding = async ({
         return {
           ok: false,
           status: 400,
-          error: `Repository "${repoUrl}" already exists and is not empty. Did you mean to use "Import existing setup"?`,
+          error: `Repository "${repoUrl}" already exists and is not empty. To import, use "Import existing setup" instead.`,
         };
       }
       const commitCheckDetails = await parseGithubErrorMessage(commitsRes);

package/lib/server/routes/gmail.js

@@ -60,7 +60,11 @@ const registerGmailRoutes = ({
     try {
       const accountId = String(req.body?.accountId || "").trim();
       if (!accountId) return res.status(400).json({ ok: false, error: "accountId is required" });
-      const result = await gmailWatchService.startWatch({ accountId, req });
+      const result = await gmailWatchService.startWatch({
+        accountId,
+        req,
+        destination: req.body?.destination || null,
+      });
       const snapshot = await getRestartSnapshot();
       return res.json({
         ...result,

package/lib/server/routes/models.js

@@ -34,6 +34,62 @@ const registerModelRoutes = ({
     return next;
   };
 
+  const readEnvVarMap = () => {
+    if (typeof readEnvFile !== "function") return new Map();
+    return new Map(
+      (readEnvFile() || []).map((entry) => [
+        String(entry?.key || "").trim(),
+        String(entry?.value || "").trim(),
+      ]),
+    );
+  };
+
+  const buildEnvBackedProfiles = (agentId) => {
+    const envMap = readEnvVarMap();
+    const providers = authProfiles.listApiKeyProviders?.() || [];
+    return providers.flatMap((provider) => {
+      const envKey = authProfiles.getEnvVarForApiKeyProvider?.(provider);
+      const envValue = String(envMap.get(envKey) || "").trim();
+      if (!envKey || !envValue) return [];
+      const profileId =
+        authProfiles.getDefaultProfileIdForApiKeyProvider?.(provider) ||
+        `${provider}:default`;
+      return [
+        {
+          id: profileId,
+          type: "api_key",
+          provider,
+          key: envValue,
+        },
+      ];
+    });
+  };
+
+  const mergeProfilesWithEnvFallback = (profiles, agentId) => {
+    const mergedProfiles = Array.isArray(profiles) ? [...profiles] : [];
+    const profileIndexById = new Map(
+      mergedProfiles.map((profile, index) => [profile?.id, index]),
+    );
+    for (const envProfile of buildEnvBackedProfiles(agentId)) {
+      const existingIndex = profileIndexById.get(envProfile.id);
+      if (existingIndex === undefined) {
+        profileIndexById.set(envProfile.id, mergedProfiles.length);
+        mergedProfiles.push(envProfile);
+        continue;
+      }
+      const existingProfile = mergedProfiles[existingIndex] || {};
+      const existingValue = String(
+        existingProfile?.key || existingProfile?.token || existingProfile?.access || "",
+      ).trim();
+      if (existingValue) continue;
+      mergedProfiles[existingIndex] = {
+        ...existingProfile,
+        ...envProfile,
+      };
+    }
+    return mergedProfiles;
+  };
+
   const syncEnvVarsForProfiles = (profiles) => {
     if (
       !Array.isArray(profiles) ||
@@ -62,6 +118,28 @@ const registerModelRoutes = ({
     reloadEnv();
   };
 
+  const syncProfilesFromEnvVars = (agentId) => {
+    if (
+      typeof readEnvFile !== "function" ||
+      typeof authProfiles.upsertApiKeyProfileForEnvVar !== "function" ||
+      typeof authProfiles.removeApiKeyProfileForEnvVar !== "function"
+    ) {
+      return;
+    }
+    const envMap = readEnvVarMap();
+    const providers = authProfiles.listApiKeyProviders?.() || [];
+    for (const provider of providers) {
+      const envKey = authProfiles.getEnvVarForApiKeyProvider?.(provider);
+      if (!envKey) continue;
+      const envValue = String(envMap.get(envKey) || "").trim();
+      if (!envValue) {
+        authProfiles.removeApiKeyProfileForEnvVar(provider, agentId);
+        continue;
+      }
+      authProfiles.upsertApiKeyProfileForEnvVar(provider, envValue, agentId);
+    }
+  };
+
   // ── Existing CLI-backed catalog/status routes ──
 
   app.get("/api/models", async (req, res) => {
@@ -135,7 +213,10 @@ const registerModelRoutes = ({
     try {
       const { primary, configuredModels } = authProfiles.getModelConfig();
       const agentId = req.query.agentId || undefined;
-      const profiles = authProfiles.listProfiles(agentId);
+      const profiles = mergeProfilesWithEnvFallback(
+        authProfiles.listProfiles(agentId),
+        agentId,
+      );
       const store = authProfiles.loadAuthStore(agentId);
       res.json({
         ok: true,
@@ -179,6 +260,8 @@ const registerModelRoutes = ({
         syncEnvVarsForProfiles(profiles);
       }
 
+      syncProfilesFromEnvVars(agentId);
+
       if (authOrder && typeof authOrder === "object") {
         for (const [provider, order] of Object.entries(authOrder)) {
           if (Array.isArray(order)) {

package/lib/server/routes/system.js

@@ -107,29 +107,7 @@ const registerSystemRoutes = ({
         String(entry?.value || ""),
       ]),
     );
-    const providers = [
-      "anthropic",
-      "openai",
-      "google",
-      "opencode",
-      "openrouter",
-      "zai",
-      "vercel-ai-gateway",
-      "kilocode",
-      "xai",
-      "mistral",
-      "cerebras",
-      "moonshot",
-      "kimi-coding",
-      "volcengine",
-      "byteplus",
-      "synthetic",
-      "minimax",
-      "voyage",
-      "groq",
-      "deepgram",
-      "vllm",
-    ];
+    const providers = authProfiles.listApiKeyProviders?.() || [];
     for (const provider of providers) {
       const envKey = authProfiles.getEnvVarForApiKeyProvider?.(provider);
       if (!envKey) continue;
@@ -141,6 +119,30 @@ const registerSystemRoutes = ({
       authProfiles.upsertApiKeyProfileForEnvVar(provider, value);
     }
   };
+  const getSessionReplyTarget = (sessionKey = "") => {
+    const key = String(sessionKey || "");
+    const telegramDirectMatch = key.match(/:telegram:direct:([^:]+)$/);
+    if (telegramDirectMatch) {
+      return {
+        replyChannel: "telegram",
+        replyTo: String(telegramDirectMatch[1] || ""),
+      };
+    }
+    const telegramTopicMatch = key.match(
+      /:telegram:group:([^:]+):topic:([^:]+)$/,
+    );
+    if (telegramTopicMatch) {
+      return {
+        replyChannel: "telegram",
+        replyTo: `${String(telegramTopicMatch[1] || "")}:${String(telegramTopicMatch[2] || "")}`,
+      };
+    }
+    return {
+      replyChannel: "",
+      replyTo: "",
+    };
+  };
+
   const listSendableAgentSessions = async () => {
     const result = await clawCmd("sessions --json", { quiet: true });
     if (!result.ok) {
@@ -163,14 +165,14 @@ const registerSystemRoutes = ({
       })
       .map((sessionRow) => {
         const key = String(sessionRow?.key || "");
-        const telegramMatch = key.match(/:telegram:direct:([^:]+)$/);
+        const replyTarget = getSessionReplyTarget(key);
         return {
           key,
           sessionId: String(sessionRow?.sessionId || ""),
           updatedAt: Number(sessionRow?.updatedAt) || 0,
           label: buildSessionLabel(sessionRow),
-          replyChannel: telegramMatch ? "telegram" : "",
-          replyTo: telegramMatch ? String(telegramMatch[1] || "") : "",
+          replyChannel: replyTarget.replyChannel,
+          replyTo: replyTarget.replyTo,
         };
       })
       .sort((a, b) => b.updatedAt - a.updatedAt);

package/lib/server/routes/webhooks.js

@@ -136,9 +136,9 @@ const registerWebhookRoutes = ({
 
   app.post("/api/webhooks", async (req, res) => {
     try {
-      const { name: rawName } = req.body || {};
+      const { name: rawName, destination = null } = req.body || {};
       const name = validateWebhookName(rawName);
-      const webhook = createWebhook({ fs, constants, name });
+      const webhook = createWebhook({ fs, constants, name, destination });
       const baseUrl = getBaseUrl(req);
       const urls = buildWebhookUrls({ baseUrl, name });
       const syncWarning = await runWebhookGitSync("create", name);