@chrysb/alphaclaw 0.5.1 → 0.5.3

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

@@ -1,7 +1,12 @@
 export const getModelProvider = (modelKey) => String(modelKey || "").split("/")[0] || "";
 
-export const getAuthProviderFromModelProvider = (provider) =>
-  provider === "openai-codex" ? "openai" : provider;
+export const getAuthProviderFromModelProvider = (provider) => {
+  const normalized = String(provider || "").trim();
+  if (normalized === "openai-codex") return "openai";
+  if (normalized === "volcengine-plan") return "volcengine";
+  if (normalized === "byteplus-plan") return "byteplus";
+  return normalized;
+};
 
 export const kFeaturedModelDefs = [
   {
@@ -71,6 +76,50 @@ export const kProviderAuthFields = {
       placeholder: "AI...",
     },
   ],
+  opencode: [
+    {
+      key: "OPENCODE_API_KEY",
+      label: "OpenCode API Key",
+      placeholder: "oc-...",
+    },
+  ],
+  openrouter: [
+    {
+      key: "OPENROUTER_API_KEY",
+      label: "OpenRouter API Key",
+      url: "https://openrouter.ai",
+      linkText: "Get key",
+      placeholder: "sk-or-...",
+    },
+  ],
+  zai: [
+    {
+      key: "ZAI_API_KEY",
+      label: "Z.AI API Key",
+      placeholder: "zai-...",
+    },
+  ],
+  "vercel-ai-gateway": [
+    {
+      key: "AI_GATEWAY_API_KEY",
+      label: "AI Gateway API Key",
+      placeholder: "aigw_...",
+    },
+  ],
+  kilocode: [
+    {
+      key: "KILOCODE_API_KEY",
+      label: "KiloCode API Key",
+      placeholder: "kilo_...",
+    },
+  ],
+  xai: [
+    {
+      key: "XAI_API_KEY",
+      label: "xAI API Key",
+      placeholder: "xai-...",
+    },
+  ],
   mistral: [
     {
       key: "MISTRAL_API_KEY",
@@ -98,6 +147,55 @@ export const kProviderAuthFields = {
       placeholder: "gsk_...",
     },
   ],
+  cerebras: [
+    {
+      key: "CEREBRAS_API_KEY",
+      label: "Cerebras API Key",
+      placeholder: "csk-...",
+    },
+  ],
+  moonshot: [
+    {
+      key: "MOONSHOT_API_KEY",
+      label: "Moonshot API Key",
+      placeholder: "sk-...",
+    },
+  ],
+  "kimi-coding": [
+    {
+      key: "KIMI_API_KEY",
+      label: "Kimi API Key",
+      placeholder: "sk-...",
+    },
+  ],
+  volcengine: [
+    {
+      key: "VOLCANO_ENGINE_API_KEY",
+      label: "Volcano Engine API Key",
+      placeholder: "ve-...",
+    },
+  ],
+  byteplus: [
+    {
+      key: "BYTEPLUS_API_KEY",
+      label: "BytePlus API Key",
+      placeholder: "bp-...",
+    },
+  ],
+  synthetic: [
+    {
+      key: "SYNTHETIC_API_KEY",
+      label: "Synthetic API Key",
+      placeholder: "syn-...",
+    },
+  ],
+  minimax: [
+    {
+      key: "MINIMAX_API_KEY",
+      label: "MiniMax API Key",
+      placeholder: "minimax-...",
+    },
+  ],
   deepgram: [
     {
       key: "DEEPGRAM_API_KEY",
@@ -107,26 +205,61 @@ export const kProviderAuthFields = {
       placeholder: "dg-...",
     },
   ],
+  vllm: [
+    {
+      key: "VLLM_API_KEY",
+      label: "vLLM API Key",
+      placeholder: "vllm-local",
+    },
+  ],
 };
 
 export const kProviderLabels = {
   anthropic: "Anthropic",
   openai: "OpenAI",
   google: "Gemini",
+  opencode: "OpenCode Zen",
+  openrouter: "OpenRouter",
+  zai: "Z.AI",
+  "vercel-ai-gateway": "Vercel AI Gateway",
+  kilocode: "Kilo Gateway",
+  xai: "xAI",
   mistral: "Mistral",
+  cerebras: "Cerebras",
+  moonshot: "Moonshot",
+  "kimi-coding": "Kimi Coding",
+  volcengine: "Volcano Engine",
+  byteplus: "BytePlus",
+  synthetic: "Synthetic",
+  minimax: "MiniMax",
   voyage: "Voyage",
   groq: "Groq",
   deepgram: "Deepgram",
+  vllm: "vLLM",
 };
 
 export const kProviderOrder = [
   "anthropic",
   "openai",
   "google",
+  "zai",
+  "xai",
+  "openrouter",
+  "opencode",
+  "kilocode",
+  "vercel-ai-gateway",
+  "minimax",
+  "moonshot",
+  "kimi-coding",
+  "volcengine",
+  "byteplus",
+  "synthetic",
   "mistral",
+  "cerebras",
   "voyage",
   "groq",
   "deepgram",
+  "vllm",
 ];
 
 export const kCoreProviders = new Set(["anthropic", "openai", "google"]);
@@ -135,10 +268,24 @@ export const kProviderFeatures = {
   anthropic: ["Agent Model"],
   openai: ["Agent Model", "Embeddings", "Audio"],
   google: ["Agent Model", "Embeddings", "Audio"],
+  opencode: ["Agent Model"],
+  openrouter: ["Agent Model"],
+  zai: ["Agent Model"],
+  "vercel-ai-gateway": ["Agent Model"],
+  kilocode: ["Agent Model"],
+  xai: ["Agent Model"],
   mistral: ["Agent Model", "Embeddings", "Audio"],
+  cerebras: ["Agent Model"],
+  moonshot: ["Agent Model"],
+  "kimi-coding": ["Agent Model"],
+  volcengine: ["Agent Model"],
+  byteplus: ["Agent Model"],
+  synthetic: ["Agent Model"],
+  minimax: ["Agent Model"],
   voyage: ["Embeddings"],
   groq: ["Agent Model", "Audio"],
   deepgram: ["Audio"],
+  vllm: ["Agent Model"],
 };
 
 export const kFeatureDefs = [

package/lib/server/auth-profiles.js

@@ -7,10 +7,24 @@ const kApiKeyEnvVarByProvider = {
   anthropic: "ANTHROPIC_API_KEY",
   openai: "OPENAI_API_KEY",
   google: "GEMINI_API_KEY",
+  opencode: "OPENCODE_API_KEY",
+  openrouter: "OPENROUTER_API_KEY",
+  zai: "ZAI_API_KEY",
+  "vercel-ai-gateway": "AI_GATEWAY_API_KEY",
+  kilocode: "KILOCODE_API_KEY",
+  xai: "XAI_API_KEY",
   mistral: "MISTRAL_API_KEY",
+  cerebras: "CEREBRAS_API_KEY",
+  moonshot: "MOONSHOT_API_KEY",
+  "kimi-coding": "KIMI_API_KEY",
+  volcengine: "VOLCANO_ENGINE_API_KEY",
+  byteplus: "BYTEPLUS_API_KEY",
+  synthetic: "SYNTHETIC_API_KEY",
+  minimax: "MINIMAX_API_KEY",
   voyage: "VOYAGE_API_KEY",
   groq: "GROQ_API_KEY",
   deepgram: "DEEPGRAM_API_KEY",
+  vllm: "VLLM_API_KEY",
 };
 
 const normalizeSecret = (raw) =>

package/lib/server/constants.js

@@ -12,9 +12,9 @@ const kNpmPackageRoot = path.resolve(kPackageRoot, "..");
 const kSetupDir = path.join(kPackageRoot, "setup");
 
 const PORT = parseInt(process.env.PORT || "3000", 10);
-const GATEWAY_PORT = 18789;
+const kDefaultGatewayPort = 18789;
 const GATEWAY_HOST = "127.0.0.1";
-const GATEWAY_URL = `http://${GATEWAY_HOST}:${GATEWAY_PORT}`;
+const kDefaultGatewayUrl = `http://${GATEWAY_HOST}:${kDefaultGatewayPort}`;
 const OPENCLAW_DIR = path.join(kRootDir, ".openclaw");
 const GATEWAY_TOKEN = process.env.OPENCLAW_GATEWAY_TOKEN || "";
 const ENV_FILE_PATH = path.join(kRootDir, ".env");
@@ -71,6 +71,25 @@ const kOnboardingModelProviders = new Set([
   "openai",
   "openai-codex",
   "google",
+  "opencode",
+  "openrouter",
+  "zai",
+  "vercel-ai-gateway",
+  "kilocode",
+  "xai",
+  "mistral",
+  "cerebras",
+  "moonshot",
+  "kimi-coding",
+  "volcengine",
+  "volcengine-plan",
+  "byteplus",
+  "byteplus-plan",
+  "synthetic",
+  "minimax",
+  "voyage",
+  "groq",
+  "vllm",
 ]);
 const kFallbackOnboardingModels = [
   {
@@ -354,9 +373,9 @@ module.exports = {
   kNpmPackageRoot,
   kSetupDir,
   PORT,
-  GATEWAY_PORT,
+  kDefaultGatewayPort,
   GATEWAY_HOST,
-  GATEWAY_URL,
+  kDefaultGatewayUrl,
   OPENCLAW_DIR,
   GATEWAY_TOKEN,
   ENV_FILE_PATH,

package/lib/server/gateway.js

@@ -6,7 +6,7 @@ const {
   ALPHACLAW_DIR,
   OPENCLAW_DIR,
   GATEWAY_HOST,
-  GATEWAY_PORT,
+  kDefaultGatewayPort,
   kControlUiSkillPath,
   kChannelDefs,
   kOnboardingMarkerPath,
@@ -74,9 +74,23 @@ const isOnboarded = () => {
   return false;
 };
 
+const getGatewayPort = () => {
+  try {
+    const configPath = `${OPENCLAW_DIR}/openclaw.json`;
+    if (!fs.existsSync(configPath)) return kDefaultGatewayPort;
+    const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    const parsedPort = Number.parseInt(String(cfg?.gateway?.port || ""), 10);
+    return parsedPort > 0 ? parsedPort : kDefaultGatewayPort;
+  } catch {
+    return kDefaultGatewayPort;
+  }
+};
+
+const getGatewayUrl = () => `http://${GATEWAY_HOST}:${getGatewayPort()}`;
+
 const isGatewayRunning = () =>
   new Promise((resolve) => {
-    const sock = net.createConnection(GATEWAY_PORT, GATEWAY_HOST);
+    const sock = net.createConnection(getGatewayPort(), GATEWAY_HOST);
     sock.setTimeout(1000);
     sock.on("connect", () => {
       sock.destroy();
@@ -341,6 +355,8 @@ const getChannelStatus = () => {
 
 module.exports = {
   gatewayEnv,
+  getGatewayPort,
+  getGatewayUrl,
   isOnboarded,
   isGatewayRunning,
   launchGatewayProcess,

package/lib/server/onboarding/import/import-applier.js

@@ -4,6 +4,11 @@ const {
   normalizeHookPath,
   normalizeTransformModulePath,
 } = require("./import-config");
+const {
+  getCanonicalEnvVarForConfigPath,
+  getEnvRefName,
+  isAlreadyEnvRef,
+} = require("./secret-detector");
 
 const kEnvVarNamePattern = /^[A-Z_][A-Z0-9_]*$/;
 
@@ -147,6 +152,41 @@ const resolveExtractionTargetPath = (baseDir, file) => {
   }
   return resolvedFilePath;
 };
+const isConfigPathIndex = (segment) => /^\d+$/.test(String(segment || ""));
+const setConfigValueAtPath = ({
+  root,
+  dotPath,
+  expectedValue,
+  nextValue,
+}) => {
+  const pathSegments = String(dotPath || "")
+    .split(".")
+    .filter(Boolean);
+  if (!root || typeof root !== "object" || pathSegments.length === 0) {
+    return false;
+  }
+
+  let current = root;
+  for (let index = 0; index < pathSegments.length - 1; index += 1) {
+    const segment = pathSegments[index];
+    const nextNode = isConfigPathIndex(segment)
+      ? current?.[Number(segment)]
+      : current?.[segment];
+    if (!nextNode || typeof nextNode !== "object") {
+      return false;
+    }
+    current = nextNode;
+  }
+
+  const lastSegment = pathSegments[pathSegments.length - 1];
+  const targetKey = isConfigPathIndex(lastSegment)
+    ? Number(lastSegment)
+    : lastSegment;
+  if (typeof current?.[targetKey] !== "string") return false;
+  if (current[targetKey] !== expectedValue) return false;
+  current[targetKey] = nextValue;
+  return true;
+};
 const movePath = (fs, src, dest) => {
   fs.mkdirSync(path.dirname(dest), { recursive: true });
   try {
@@ -280,6 +320,7 @@ const applySecretExtraction = ({ fs, baseDir, approvedSecrets }) => {
         rewriteMap.set(fullPath, []);
       }
       rewriteMap.get(fullPath).push({
+        configPath: secret.configPath,
         value,
         envRef: `\${${envVar}}`,
         relativeFile: secret.file,
@@ -290,9 +331,31 @@ const applySecretExtraction = ({ fs, baseDir, approvedSecrets }) => {
   for (const [fullPath, replacements] of rewriteMap) {
     try {
       let content = fs.readFileSync(fullPath, "utf8");
+      let parsed = null;
+      try {
+        parsed = JSON.parse(content);
+      } catch {}
       const sorted = [...replacements].sort(
         (a, b) => b.value.length - a.value.length,
       );
+      let structuredChanged = false;
+      if (parsed && typeof parsed === "object") {
+        for (const { configPath, value, envRef } of sorted) {
+          if (
+            setConfigValueAtPath({
+              root: parsed,
+              dotPath: configPath,
+              expectedValue: value,
+              nextValue: envRef,
+            })
+          ) {
+            structuredChanged = true;
+          }
+        }
+      }
+      if (structuredChanged) {
+        content = JSON.stringify(parsed, null, 2);
+      }
       for (const { value, envRef } of sorted) {
         const secretJson = JSON.stringify(value);
         const envRefJson = JSON.stringify(envRef);
@@ -313,9 +376,73 @@ const applySecretExtraction = ({ fs, baseDir, approvedSecrets }) => {
   return { envVars };
 };
 
+const remapEnvVars = (envVars, renameMap) => {
+  const mapped = [];
+  for (const entry of envVars) {
+    const key = String(entry?.key || "").trim();
+    if (!key) continue;
+    const nextKey = renameMap.get(key) || key;
+    const existing = mapped.find((item) => item.key === nextKey);
+    if (existing) {
+      existing.value = entry.value;
+    } else {
+      mapped.push({ key: nextKey, value: entry.value });
+    }
+  }
+  return mapped;
+};
+
+const canonicalizeConfigEnvRefs = ({ fs, baseDir, configFiles = [], envVars = [] }) => {
+  const renameMap = new Map();
+  let rewrittenRefs = 0;
+
+  const rewriteNode = (node, parentPath = "") => {
+    if (!node || typeof node !== "object") return false;
+    let changed = false;
+    for (const [key, value] of Object.entries(node)) {
+      const dotPath = parentPath ? `${parentPath}.${key}` : key;
+      if (typeof value === "string" && isAlreadyEnvRef(value)) {
+        const currentEnvRef = getEnvRefName(value);
+        const canonicalEnvVar = getCanonicalEnvVarForConfigPath(dotPath);
+        if (canonicalEnvVar && currentEnvRef && currentEnvRef !== canonicalEnvVar) {
+          node[key] = `\${${canonicalEnvVar}}`;
+          renameMap.set(currentEnvRef, canonicalEnvVar);
+          rewrittenRefs += 1;
+          changed = true;
+        }
+        continue;
+      }
+      if (value && typeof value === "object") {
+        changed = rewriteNode(value, dotPath) || changed;
+      }
+    }
+    return changed;
+  };
+
+  for (const configFile of configFiles) {
+    const fullPath = resolveExtractionTargetPath(baseDir, configFile);
+    if (!fullPath) continue;
+    try {
+      const parsed = JSON.parse(fs.readFileSync(fullPath, "utf8"));
+      if (!parsed || typeof parsed !== "object") continue;
+      const changed = rewriteNode(parsed);
+      if (changed) {
+        fs.writeFileSync(fullPath, JSON.stringify(parsed, null, 2));
+      }
+    } catch {}
+  }
+
+  return {
+    envVars: remapEnvVars(envVars, renameMap),
+    rewrittenRefs,
+    renamedEnvVars: renameMap.size,
+  };
+};
+
 module.exports = {
   promoteCloneToTarget,
   alignHookTransforms,
   applySecretExtraction,
+  canonicalizeConfigEnvRefs,
   isValidTempDir,
 };

package/lib/server/onboarding/import/import-scanner.js

@@ -220,6 +220,7 @@ const collectManagedEnvRefs = (value, found) => {
 const collectManagedEnvConflicts = (fs, baseDir, configFiles, envFiles) => {
   const managedVars = new Set();
   let gatewayAuthNormalized = false;
+  let webhookTokenNormalized = false;
 
   for (const configFile of configFiles) {
     try {
@@ -231,6 +232,11 @@ const collectManagedEnvConflicts = (fs, baseDir, configFiles, envFiles) => {
         gatewayAuthNormalized = true;
         managedVars.add("OPENCLAW_GATEWAY_TOKEN");
       }
+      const webhookToken = String(cfg?.hooks?.token || "").trim();
+      if (webhookToken && webhookToken !== "${WEBHOOK_TOKEN}") {
+        webhookTokenNormalized = true;
+        managedVars.add("WEBHOOK_TOKEN");
+      }
     } catch {}
   }
 
@@ -251,9 +257,10 @@ const collectManagedEnvConflicts = (fs, baseDir, configFiles, envFiles) => {
   }
 
   return {
-    found: managedVars.size > 0 || gatewayAuthNormalized,
+    found: managedVars.size > 0 || gatewayAuthNormalized || webhookTokenNormalized,
     vars: [...managedVars].sort(),
     gatewayAuthNormalized,
+    webhookTokenNormalized,
   };
 };
 

package/lib/server/onboarding/import/secret-detector.js

@@ -59,14 +59,27 @@ const kConfigPathToEnvVar = {
   "models.providers.openai.apiKey": "OPENAI_API_KEY",
   "models.providers.anthropic.apiKey": "ANTHROPIC_API_KEY",
   "models.providers.google.apiKey": "GEMINI_API_KEY",
+  "models.providers.opencode.apiKey": "OPENCODE_API_KEY",
   "models.providers.openrouter.apiKey": "OPENROUTER_API_KEY",
+  "models.providers.zai.apiKey": "ZAI_API_KEY",
+  "models.providers.vercel-ai-gateway.apiKey": "AI_GATEWAY_API_KEY",
+  "models.providers.kilocode.apiKey": "KILOCODE_API_KEY",
+  "models.providers.xai.apiKey": "XAI_API_KEY",
   "models.providers.mistral.apiKey": "MISTRAL_API_KEY",
   "models.providers.groq.apiKey": "GROQ_API_KEY",
   "models.providers.cerebras.apiKey": "CEREBRAS_API_KEY",
+  "models.providers.moonshot.apiKey": "MOONSHOT_API_KEY",
+  "models.providers.kimi-coding.apiKey": "KIMI_API_KEY",
+  "models.providers.volcengine.apiKey": "VOLCANO_ENGINE_API_KEY",
+  "models.providers.byteplus.apiKey": "BYTEPLUS_API_KEY",
+  "models.providers.synthetic.apiKey": "SYNTHETIC_API_KEY",
+  "models.providers.minimax.apiKey": "MINIMAX_API_KEY",
   "models.providers.voyage.apiKey": "VOYAGE_API_KEY",
+  "models.providers.vllm.apiKey": "VLLM_API_KEY",
   "tools.web.search.apiKey": "BRAVE_API_KEY",
   "audio.apiKey": "ELEVENLABS_API_KEY",
   "talk.apiKey": "ELEVENLABS_API_KEY",
+  "hooks.token": null, // Dropped — normalized to WEBHOOK_TOKEN at deploy/import time
   "gateway.auth.token": null, // Dropped — set at deploy time
 };
 
@@ -99,15 +112,31 @@ const maskValue = (value) => {
   return str.slice(0, 4) + "****" + str.slice(-4);
 };
 
-const configPathToEnvName = (dotPath) => {
+const toEnvSegment = (value) =>
+  String(value || "")
+    .replace(/([a-z])([A-Z])/g, "$1_$2")
+    .toUpperCase()
+    .replace(/[^A-Z0-9_]/g, "_");
+
+const getCanonicalEnvVarForConfigPath = (dotPath) => {
   if (kConfigPathToEnvVar[dotPath] !== undefined) {
     return kConfigPathToEnvVar[dotPath];
   }
+  const providerPathMatch = String(dotPath || "").match(
+    /^models\.providers\.([^.]+)\.([^.]+)$/,
+  );
+  if (providerPathMatch) {
+    const [, providerKey, fieldKey] = providerPathMatch;
+    return `${toEnvSegment(providerKey)}_${toEnvSegment(fieldKey)}`;
+  }
+  return "";
+};
+
+const configPathToEnvName = (dotPath) => {
+  const canonicalName = getCanonicalEnvVarForConfigPath(dotPath);
+  if (canonicalName) return canonicalName;
   const lastKey = dotPath.split(".").pop() || "";
-  return lastKey
-    .replace(/([a-z])([A-Z])/g, "$1_$2")
-    .toUpperCase()
-    .replace(/[^A-Z0-9_]/g, "_");
+  return toEnvSegment(lastKey);
 };
 
 const walkConfig = (obj, parentPath, results) => {
@@ -172,6 +201,13 @@ const walkConfig = (obj, parentPath, results) => {
 const isAlreadyEnvRef = (value) =>
   /^\$\{[A-Z_][A-Z0-9_]*\}$/.test(String(value || "").trim());
 
+const getEnvRefName = (value) => {
+  const match = String(value || "")
+    .trim()
+    .match(/^\$\{([A-Z_][A-Z0-9_]*)\}$/);
+  return match?.[1] || "";
+};
+
 const parseEnvFileSecrets = (content, fileName) => {
   const results = [];
   const lines = String(content || "").split("\n");
@@ -248,6 +284,7 @@ const extractPreFillValues = ({ fs, baseDir, configFiles = [] }) => {
     try {
       const raw = fs.readFileSync(path.join(baseDir, cfgFile), "utf8");
       const cfg = JSON.parse(raw);
+      const configFileName = path.basename(String(cfgFile || "")).toLowerCase();
 
       if (cfg.models?.active) preFill.MODEL_KEY = cfg.models.active;
 
@@ -262,7 +299,12 @@ const extractPreFillValues = ({ fs, baseDir, configFiles = [] }) => {
         preFill.GEMINI_API_KEY = providers.google.apiKey;
       }
 
-      const channels = cfg.channels || {};
+      const channels =
+        cfg.channels && typeof cfg.channels === "object"
+          ? cfg.channels
+          : configFileName.includes("channel")
+            ? cfg
+            : {};
       if (channels.telegram?.botToken && !isAlreadyEnvRef(channels.telegram.botToken)) {
         preFill.TELEGRAM_BOT_TOKEN = channels.telegram.botToken;
       }
@@ -280,9 +322,13 @@ const extractPreFillValues = ({ fs, baseDir, configFiles = [] }) => {
 };
 
 module.exports = {
+  configPathToEnvName,
   detectSecrets,
   extractPreFillValues,
+  getCanonicalEnvVarForConfigPath,
+  getEnvRefName,
   isSensitiveKey,
+  isAlreadyEnvRef,
   matchesValuePrefix,
   maskValue,
   parseEnvFileSecrets,