@chrysb/alphaclaw 0.9.17 → 0.9.19

package/lib/public/js/components/api-feature-panel.js

@@ -0,0 +1,76 @@
+import { h } from "preact";
+import htm from "htm";
+import { copyTextToClipboard } from "../lib/clipboard.js";
+import { showToast } from "./toast.js";
+import { FileCopyLineIcon } from "./icons.js";
+import { InfoTooltip } from "./info-tooltip.js";
+import { ToggleSwitch } from "./toggle-switch.js";
+
+const html = htm.bind(h);
+
+const getApiUrl = () => {
+  if (typeof window === "undefined" || !window.location?.origin) return "/v1";
+  return `${window.location.origin}/v1`;
+};
+
+export const ApiFeaturePanel = ({
+  openAiCompatApi = { enabled: false },
+  savingOpenAiCompatApi = false,
+  onToggleOpenAiCompatApi = () => {},
+}) => {
+  const apiHydrated = openAiCompatApi?.hydrated === true;
+  const apiEnabled = openAiCompatApi?.enabled === true;
+  const apiUrl = getApiUrl();
+  const handleCopy = async () => {
+    const copied = await copyTextToClipboard(apiUrl);
+    showToast(
+      copied ? "API URL copied" : "Could not copy API URL",
+      copied ? "success" : "error",
+    );
+  };
+
+  return html`
+    <div class="bg-surface border border-border rounded-xl p-4">
+      <div class="flex items-center justify-between gap-3">
+        <div class="flex items-center gap-1.5 min-w-0">
+          <h2 class="card-label">API</h2>
+          <${InfoTooltip}
+            text="Allows trusted server-side clients to call OpenClaw via an OpenAI compatible API."
+            widthClass="w-72"
+          />
+        </div>
+        <${ToggleSwitch}
+          checked=${apiEnabled}
+          disabled=${savingOpenAiCompatApi || !apiHydrated}
+          label=${savingOpenAiCompatApi
+            ? "Saving..."
+            : !apiHydrated
+              ? "Loading..."
+              : apiEnabled
+                ? "Enabled"
+                : "Disabled"}
+          onChange=${onToggleOpenAiCompatApi}
+        />
+      </div>
+      ${apiHydrated && apiEnabled
+        ? html`
+            <div class="mt-4 text-xs text-fg-muted mb-2">OpenAI compatible URL</div>
+            <div class="flex items-center gap-2">
+              <code class="flex-1 min-w-0 bg-field border border-border rounded-lg px-3 py-2 text-xs text-body font-mono break-all">
+                ${apiUrl}
+              </code>
+              <button
+                type="button"
+                class="ac-btn-secondary text-xs p-2 rounded-lg shrink-0"
+                title="Copy URL"
+                aria-label="Copy API URL"
+                onclick=${handleCopy}
+              >
+                <${FileCopyLineIcon} className="w-4 h-4" />
+              </button>
+            </div>
+          `
+        : null}
+    </div>
+  `;
+};

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

@@ -8,6 +8,7 @@ import { DevicePairings } from "../device-pairings.js";
 import { ActionButton } from "../action-button.js";
 import { Google } from "../google/index.js";
 import { Features } from "../features.js";
+import { ApiFeaturePanel } from "../api-feature-panel.js";
 import { GeneralDoctorWarning } from "../doctor/general-warning.js";
 import { ChevronDownIcon } from "../icons.js";
 import { UpdateActionButton } from "../update-action-button.js";
@@ -136,6 +137,11 @@ export const GeneralTab = ({
         onRestartRequired=${onRestartRequired}
         onOpenGmailWebhook=${onOpenGmailWebhook}
       />
+      <${ApiFeaturePanel}
+        openAiCompatApi=${state.openAiCompatApi}
+        savingOpenAiCompatApi=${state.savingOpenAiCompatApi}
+        onToggleOpenAiCompatApi=${actions.handleOpenAiCompatApiToggle}
+      />
 
       ${state.repo &&
       html`

package/lib/public/js/components/general/use-general-tab.js

@@ -8,14 +8,36 @@ import {
   rejectDevice,
   rejectPairing,
   triggerWatchdogRepair,
+  updateOpenAiCompatApiFeature,
   updateSyncCron,
 } from "../../lib/api.js";
 import { usePolling } from "../../hooks/usePolling.js";
+import {
+  kOpenAiCompatApiFeatureCacheKey,
+} from "../../lib/storage-keys.js";
 import { showToast } from "../toast.js";
 import { ALL_CHANNELS } from "../channels.js";
 
 const kDefaultSyncCronSchedule = "0 * * * *";
 
+const readCachedOpenAiCompatApi = () => {
+  try {
+    const rawValue = window.localStorage.getItem(kOpenAiCompatApiFeatureCacheKey);
+    if (rawValue === "true") return { enabled: true, hydrated: true };
+    if (rawValue === "false") return { enabled: false, hydrated: true };
+  } catch {}
+  return { enabled: false, hydrated: false };
+};
+
+const writeCachedOpenAiCompatApi = (enabled) => {
+  try {
+    window.localStorage.setItem(
+      kOpenAiCompatApiFeatureCacheKey,
+      enabled ? "true" : "false",
+    );
+  } catch {}
+};
+
 export const useGeneralTab = ({
   statusData = null,
   watchdogData = null,
@@ -30,6 +52,14 @@ export const useGeneralTab = ({
   const [syncCronSchedule, setSyncCronSchedule] = useState(kDefaultSyncCronSchedule);
   const [savingSyncCron, setSavingSyncCron] = useState(false);
   const [syncCronChoice, setSyncCronChoice] = useState(kDefaultSyncCronSchedule);
+  const [cachedOpenAiCompatApi] = useState(readCachedOpenAiCompatApi);
+  const [openAiCompatApiEnabled, setOpenAiCompatApiEnabled] = useState(
+    cachedOpenAiCompatApi.enabled,
+  );
+  const [openAiCompatApiHydrated, setOpenAiCompatApiHydrated] = useState(
+    cachedOpenAiCompatApi.hydrated,
+  );
+  const [savingOpenAiCompatApi, setSavingOpenAiCompatApi] = useState(false);
   const [pairingStatusRefreshing, setPairingStatusRefreshing] = useState(false);
   const [devicePollingEnabled, setDevicePollingEnabled] = useState(false);
   const [cliAutoApproveComplete, setCliAutoApproveComplete] = useState(false);
@@ -42,6 +72,8 @@ export const useGeneralTab = ({
   const channels = status?.channels ?? null;
   const repo = status?.repo || null;
   const syncCron = status?.syncCron || null;
+  const openAiCompatApi = status?.alphaclaw?.features?.openaiCompatApi || null;
+  const hasOpenAiCompatApiStatus = typeof openAiCompatApi?.enabled === "boolean";
   const openclawVersion = status?.openclawVersion || null;
 
   const hasUnpaired = ALL_CHANNELS.some((channel) => {
@@ -134,6 +166,14 @@ export const useGeneralTab = ({
     );
   }, [syncCron?.enabled, syncCron?.schedule]);
 
+  useEffect(() => {
+    if (!hasOpenAiCompatApiStatus) return;
+    const nextEnabled = openAiCompatApi.enabled === true;
+    setOpenAiCompatApiEnabled(nextEnabled);
+    setOpenAiCompatApiHydrated(true);
+    writeCachedOpenAiCompatApi(nextEnabled);
+  }, [hasOpenAiCompatApiStatus, openAiCompatApi?.enabled]);
+
   useEffect(
     () => () => {
       if (pairingRefreshTimerRef.current) {
@@ -196,6 +236,28 @@ export const useGeneralTab = ({
     });
   };
 
+  const handleOpenAiCompatApiToggle = async (enabled) => {
+    if (savingOpenAiCompatApi) return;
+    const previousEnabled = openAiCompatApiEnabled;
+    setOpenAiCompatApiEnabled(enabled);
+    setSavingOpenAiCompatApi(true);
+    try {
+      const data = await updateOpenAiCompatApiFeature(enabled);
+      if (!data.ok) {
+        throw new Error(data.error || "Could not save API setting");
+      }
+      writeCachedOpenAiCompatApi(enabled);
+      setOpenAiCompatApiHydrated(true);
+      showToast(`API ${enabled ? "enabled" : "disabled"}`, "success");
+      onRefreshStatuses();
+    } catch (err) {
+      setOpenAiCompatApiEnabled(previousEnabled);
+      showToast(err.message || "Could not save API setting", "error");
+    } finally {
+      setSavingOpenAiCompatApi(false);
+    }
+  };
+
   const handleApprove = async (id, channel, accountId = "") => {
     try {
       const result = await approvePairing(id, channel, accountId);
@@ -288,12 +350,18 @@ export const useGeneralTab = ({
       gatewayStatus,
       hasUnpaired,
       openclawVersion,
+      openAiCompatApi: {
+        ...(openAiCompatApi || {}),
+        enabled: openAiCompatApiEnabled,
+        hydrated: openAiCompatApiHydrated,
+      },
       pending,
       pairingsPolling: pairingsPoll.isPolling,
       pairingStatusRefreshing,
       repairingWatchdog,
       repo,
       savingSyncCron,
+      savingOpenAiCompatApi,
       syncCron,
       syncCronChoice,
       syncCronEnabled,
@@ -306,6 +374,7 @@ export const useGeneralTab = ({
       handleDeviceApprove,
       handleDeviceReject,
       handleOpenDashboard,
+      handleOpenAiCompatApiToggle,
       handleReject,
       handleSyncCronChoiceChange,
       handleWatchdogRepair,

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

@@ -550,6 +550,25 @@ export async function updateSyncCron(payload) {
   return data;
 }
 
+export async function updateOpenAiCompatApiFeature(enabled) {
+  const res = await authFetch("/api/alphaclaw/config/features/openai-compat-api", {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ enabled }),
+  });
+  const text = await res.text();
+  let data;
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+    throw new Error(text || "Could not parse AlphaClaw config response");
+  }
+  if (!res.ok) {
+    throw new Error(data.error || text || `HTTP ${res.status}`);
+  }
+  return data;
+}
+
 export async function fetchCronJobs({ sortBy = "nextRunAtMs", sortDir = "asc" } = {}) {
   const params = new URLSearchParams();
   if (sortBy) params.set("sortBy", String(sortBy));

package/lib/public/js/lib/storage-keys.js

@@ -31,3 +31,7 @@ export const kAgentLastSessionKey = "alphaclaw.agent.lastSessionKey";
 
 // --- Chat ---
 export const kChatSessionDraftsStorageKey = "alphaclaw.chat.sessionDrafts";
+
+// --- Features ---
+export const kOpenAiCompatApiFeatureCacheKey =
+  "alphaclaw.features.openAiCompatApi.enabled";

package/lib/scripts/git

@@ -4,7 +4,7 @@
 
 REAL_GIT_HINT="@@REAL_GIT@@"
 OPENCLAW_REPO_ROOT="@@OPENCLAW_REPO_ROOT@@"
-ASKPASS_PATH="/tmp/alphaclaw-git-askpass.sh"
+ASKPASS_PATH="@@ASKPASS_PATH@@"
 
 same_path() {
   local left_path right_path

package/lib/server/agents/shared.js

@@ -505,12 +505,16 @@ const readPairedCountsByAccount = ({
   } catch {}
 
   for (const accountId of counts.keys()) {
-    if (String(channelId || "").trim() === "whatsapp") continue;
     const accountConfig =
       accountId === "default" &&
       !(config.accounts && typeof config.accounts === "object")
         ? config
         : config.accounts?.[accountId] || {};
+    if (String(channelId || "").trim() === "whatsapp") {
+      if (!hasSavedWhatsAppCredentials({ fsImpl, OPENCLAW_DIR, accountId })) {
+        continue;
+      }
+    }
     const inlineAllowFrom = accountConfig?.allowFrom;
     if (!Array.isArray(inlineAllowFrom)) continue;
     counts.set(
@@ -616,7 +620,15 @@ const listConfiguredChannelAccounts = ({ fsImpl, OPENCLAW_DIR, cfg }) => {
             status:
               Number(pairedCounts.get(accountId) || 0) > 0
                 ? "paired"
-                : "configured",
+                : hasImplicitWhatsAppSelfPairing({
+                    fsImpl,
+                    OPENCLAW_DIR,
+                    channelId,
+                    accountId,
+                    accountConfig,
+                  })
+                  ? "paired"
+                  : "configured",
           };
         }),
       };
@@ -764,6 +776,10 @@ module.exports = {
   resolveCredentialsDirPath,
   resolveWhatsAppCredentialCandidatePaths,
   hasSavedWhatsAppCredentials,
+  normalizeChannelAccountId,
+  resolveCredentialPairingAccountId,
+  hasImplicitWhatsAppSelfPairing,
+  readPairedCountsByAccount,
   resolveAgentWorkspacePath,
   loadConfig,
   saveConfig,

package/lib/server/alphaclaw-config.js

@@ -0,0 +1,99 @@
+const fs = require("fs");
+const path = require("path");
+
+const kConfigFileName = "alphaclaw.json";
+const kDefaultAlphaclawConfig = Object.freeze({
+  features: Object.freeze({
+    openaiCompatApi: Object.freeze({
+      enabled: false,
+    }),
+  }),
+});
+
+const resolveAlphaclawConfigPath = ({ openclawDir } = {}) =>
+  path.join(openclawDir || process.cwd(), kConfigFileName);
+
+const normalizeOpenAiCompatApiFeature = (feature = {}) => ({
+  ...(feature && typeof feature === "object" ? feature : {}),
+  enabled: feature?.enabled === true,
+});
+
+const normalizeAlphaclawConfig = (raw = {}) => {
+  const base = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  const features =
+    base.features && typeof base.features === "object" && !Array.isArray(base.features)
+      ? base.features
+      : {};
+  return {
+    ...base,
+    features: {
+      ...features,
+      openaiCompatApi: normalizeOpenAiCompatApiFeature(features.openaiCompatApi),
+    },
+  };
+};
+
+const readAlphaclawConfig = ({
+  fsModule = fs,
+  openclawDir,
+  fallback = kDefaultAlphaclawConfig,
+} = {}) => {
+  try {
+    const configPath = resolveAlphaclawConfigPath({ openclawDir });
+    const raw = fsModule.readFileSync(configPath, "utf8");
+    return normalizeAlphaclawConfig(JSON.parse(raw));
+  } catch {
+    return normalizeAlphaclawConfig(fallback);
+  }
+};
+
+const writeAlphaclawConfig = ({
+  fsModule = fs,
+  openclawDir,
+  config,
+  spacing = 2,
+} = {}) => {
+  const configPath = resolveAlphaclawConfigPath({ openclawDir });
+  fsModule.mkdirSync(path.dirname(configPath), { recursive: true });
+  const normalized = normalizeAlphaclawConfig(config);
+  fsModule.writeFileSync(configPath, `${JSON.stringify(normalized, null, spacing)}\n`);
+  return normalized;
+};
+
+const isOpenAiCompatApiEnabled = (options = {}) =>
+  readAlphaclawConfig(options).features.openaiCompatApi.enabled === true;
+
+const updateOpenAiCompatApiFeature = ({
+  fsModule = fs,
+  openclawDir,
+  enabled,
+} = {}) => {
+  const current = readAlphaclawConfig({ fsModule, openclawDir });
+  const next = normalizeAlphaclawConfig({
+    ...current,
+    features: {
+      ...current.features,
+      openaiCompatApi: {
+        ...current.features.openaiCompatApi,
+        enabled: enabled === true,
+      },
+    },
+  });
+  const changed =
+    current.features.openaiCompatApi.enabled !== next.features.openaiCompatApi.enabled;
+  return {
+    config: writeAlphaclawConfig({ fsModule, openclawDir, config: next }),
+    changed,
+  };
+};
+
+module.exports = {
+  kConfigFileName,
+  kDefaultAlphaclawConfig,
+  isOpenAiCompatApiEnabled,
+  normalizeAlphaclawConfig,
+  readAlphaclawConfig,
+  resolveAlphaclawConfigPath,
+  updateOpenAiCompatApiFeature,
+  writeAlphaclawConfig,
+};

package/lib/server/constants.js

@@ -81,6 +81,45 @@ const kLoginStateTtlMs = Math.max(
   ),
   kLoginMaxLockMs,
 );
+const kOpenAiCompatApiRateWindowMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_WINDOW_MS,
+  kLoginWindowMs,
+);
+const kOpenAiCompatApiRateMaxAttempts = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_MAX_ATTEMPTS,
+  10,
+);
+const kOpenAiCompatApiRateBaseLockMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_BASE_LOCK_MS,
+  kLoginBaseLockMs,
+);
+const kOpenAiCompatApiRateMaxLockMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_MAX_LOCK_MS,
+  kLoginMaxLockMs,
+);
+const kOpenAiCompatApiRateGlobalWindowMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_GLOBAL_WINDOW_MS,
+  kOpenAiCompatApiRateWindowMs,
+);
+const kOpenAiCompatApiRateGlobalMaxAttempts = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_GLOBAL_MAX_ATTEMPTS,
+  Math.max(kOpenAiCompatApiRateMaxAttempts * 10, 100),
+);
+const kOpenAiCompatApiRateGlobalBaseLockMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_GLOBAL_BASE_LOCK_MS,
+  kOpenAiCompatApiRateBaseLockMs,
+);
+const kOpenAiCompatApiRateGlobalMaxLockMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_GLOBAL_MAX_LOCK_MS,
+  kOpenAiCompatApiRateMaxLockMs,
+);
+const kOpenAiCompatApiRateStateTtlMs = Math.max(
+  parsePositiveInt(
+    process.env.OPENAI_COMPAT_API_RATE_STATE_TTL_MS,
+    Math.max(kOpenAiCompatApiRateWindowMs, kOpenAiCompatApiRateMaxLockMs) * 3,
+  ),
+  kOpenAiCompatApiRateMaxLockMs,
+);
 
 const kOnboardingModelProviders = new Set([
   "anthropic",
@@ -472,6 +511,15 @@ module.exports = {
   kLoginGlobalMaxLockMs,
   kLoginCleanupIntervalMs,
   kLoginStateTtlMs,
+  kOpenAiCompatApiRateWindowMs,
+  kOpenAiCompatApiRateMaxAttempts,
+  kOpenAiCompatApiRateBaseLockMs,
+  kOpenAiCompatApiRateMaxLockMs,
+  kOpenAiCompatApiRateGlobalWindowMs,
+  kOpenAiCompatApiRateGlobalMaxAttempts,
+  kOpenAiCompatApiRateGlobalBaseLockMs,
+  kOpenAiCompatApiRateGlobalMaxLockMs,
+  kOpenAiCompatApiRateStateTtlMs,
   kOnboardingModelProviders,
   kFallbackOnboardingModels,
   kVersionCacheTtlMs,

package/lib/server/env.js

@@ -1,21 +1,48 @@
 const fs = require("fs");
 const { ENV_FILE_PATH, kKnownVars } = require("./constants");
 
+const kSensitiveEnvKeyPattern = /token|key|password/i;
+const kEnvWatchDebounceMs = 250;
+let envWatchDebounceTimer = null;
+let lastLoadedEnvSignature = null;
+let pendingSelfWriteSignature = null;
+
+const normalizeEnvVars = (vars) => {
+  const byKey = new Map();
+  for (const entry of vars || []) {
+    const key = String(entry?.key || "").trim();
+    if (!key) continue;
+    if (byKey.has(key)) byKey.delete(key);
+    byKey.set(key, {
+      key,
+      value: String(entry?.value || ""),
+    });
+  }
+  return Array.from(byKey.values());
+};
+
+const buildEnvSignature = (vars) =>
+  JSON.stringify(normalizeEnvVars(vars).map(({ key, value }) => [key, value]));
+
+const readRawEnvFile = () => {
+  const content = fs.readFileSync(ENV_FILE_PATH, "utf8");
+  const vars = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    vars.push({
+      key: trimmed.slice(0, eqIdx).trim(),
+      value: trimmed.slice(eqIdx + 1),
+    });
+  }
+  return vars;
+};
+
 const readEnvFile = () => {
   try {
-    const content = fs.readFileSync(ENV_FILE_PATH, "utf8");
-    const vars = [];
-    for (const line of content.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-      const eqIdx = trimmed.indexOf("=");
-      if (eqIdx === -1) continue;
-      vars.push({
-        key: trimmed.slice(0, eqIdx),
-        value: trimmed.slice(eqIdx + 1),
-      });
-    }
-    return vars;
+    return normalizeEnvVars(readRawEnvFile());
   } catch {
     return [];
   }
@@ -23,22 +50,24 @@ const readEnvFile = () => {
 
 const writeEnvFile = (vars) => {
   const lines = [];
-  for (const { key, value } of vars || []) {
-    if (!key) continue;
+  const normalizedVars = normalizeEnvVars(vars);
+  for (const { key, value } of normalizedVars) {
     lines.push(`${key}=${String(value || "")}`);
   }
   fs.writeFileSync(ENV_FILE_PATH, lines.join("\n"));
+  pendingSelfWriteSignature = buildEnvSignature(normalizedVars);
 };
 
 const reloadEnv = () => {
   const vars = readEnvFile();
+  const signature = buildEnvSignature(vars);
   const fileKeys = new Set(vars.map((v) => v.key));
   let changed = false;
 
   for (const { key, value } of vars) {
     if (value && value !== process.env[key]) {
       console.log(
-        `[alphaclaw] Env updated: ${key}=${key.toLowerCase().includes("token") || key.toLowerCase().includes("key") || key.toLowerCase().includes("password") ? "***" : value}`,
+        `[alphaclaw] Env updated: ${key}=${kSensitiveEnvKeyPattern.test(key) ? "***" : value}`,
       );
       process.env[key] = value;
       changed = true;
@@ -58,21 +87,43 @@ const reloadEnv = () => {
     }
   }
 
+  lastLoadedEnvSignature = signature;
   return changed;
 };
 
+const readEnvFileSignature = () => {
+  try {
+    return buildEnvSignature(readRawEnvFile());
+  } catch {
+    return null;
+  }
+};
+
 const startEnvWatcher = () => {
   try {
     fs.watchFile(ENV_FILE_PATH, { interval: 2000 }, () => {
-      console.log(
-        `[alphaclaw] ${ENV_FILE_PATH} changed externally, reloading...`,
-      );
-      reloadEnv();
+      if (envWatchDebounceTimer) clearTimeout(envWatchDebounceTimer);
+      envWatchDebounceTimer = setTimeout(() => {
+        envWatchDebounceTimer = null;
+        const signature = readEnvFileSignature();
+        if (signature && signature === pendingSelfWriteSignature) {
+          pendingSelfWriteSignature = null;
+          lastLoadedEnvSignature = signature;
+          return;
+        }
+        pendingSelfWriteSignature = null;
+        if (signature && signature === lastLoadedEnvSignature) return;
+        console.log(
+          `[alphaclaw] ${ENV_FILE_PATH} changed externally, reloading...`,
+        );
+        reloadEnv();
+      }, kEnvWatchDebounceMs);
     });
   } catch {}
 };
 
 module.exports = {
+  normalizeEnvVars,
   readEnvFile,
   writeEnvFile,
   reloadEnv,