@chrysb/alphaclaw 0.4.6-beta.4 → 0.4.6-beta.5

package/lib/public/js/lib/browse-route.js

@@ -0,0 +1,57 @@
+export const normalizeBrowsePath = (value) => String(value || "").replace(/^\/+|\/+$/g, "");
+
+export const buildBrowseRoute = (relativePath, options = {}) => {
+  const view = String(options?.view || "edit");
+  const encodedPath = String(relativePath || "")
+    .split("/")
+    .filter(Boolean)
+    .map((segment) => encodeURIComponent(segment))
+    .join("/");
+  const baseRoute = encodedPath ? `/browse/${encodedPath}` : "/browse";
+  const params = new URLSearchParams();
+  if (view === "diff" && encodedPath) params.set("view", "diff");
+  if (options.line) params.set("line", String(options.line));
+  if (options.lineEnd) params.set("lineEnd", String(options.lineEnd));
+  const query = params.toString();
+  return query ? `${baseRoute}?${query}` : baseRoute;
+};
+
+export const parseBrowseRoute = ({ location = "", browsePreviewPath = "" } = {}) => {
+  const isBrowseRoute = location.startsWith("/browse");
+  const browseRoutePath = isBrowseRoute ? String(location || "").split("?")[0] : "";
+  const browseRouteQuery =
+    isBrowseRoute && String(location || "").includes("?")
+      ? String(location || "").split("?").slice(1).join("?")
+      : "";
+  const selectedBrowsePath = isBrowseRoute
+    ? browseRoutePath
+        .replace(/^\/browse\/?/, "")
+        .split("/")
+        .filter(Boolean)
+        .map((segment) => {
+          try {
+            return decodeURIComponent(segment);
+          } catch {
+            return segment;
+          }
+        })
+        .join("/")
+    : "";
+  const activeBrowsePath = browsePreviewPath || selectedBrowsePath;
+  const browseQueryParams = isBrowseRoute ? new URLSearchParams(browseRouteQuery) : null;
+  const browseViewerMode =
+    !browsePreviewPath && browseQueryParams?.get("view") === "diff"
+      ? "diff"
+      : "edit";
+  const browseLineTarget = Number.parseInt(browseQueryParams?.get("line") || "", 10) || 0;
+  const browseLineEndTarget = Number.parseInt(browseQueryParams?.get("lineEnd") || "", 10) || 0;
+
+  return {
+    activeBrowsePath,
+    browseLineEndTarget,
+    browseLineTarget,
+    browseViewerMode,
+    isBrowseRoute,
+    selectedBrowsePath,
+  };
+};

package/lib/public/js/lib/format.js

@@ -1,4 +1,9 @@
 const kIntegerFormatter = new Intl.NumberFormat("en-US");
+const kCompactNumberFormatter = new Intl.NumberFormat("en-US", {
+  notation: "compact",
+  minimumFractionDigits: 1,
+  maximumFractionDigits: 1,
+});
 const kUsdFormatter = new Intl.NumberFormat("en-US", {
   style: "currency",
   currency: "USD",
@@ -25,6 +30,13 @@ const isSameDay = (left, right) =>
 export const formatInteger = (value) =>
   kIntegerFormatter.format(Number(value || 0));
 
+export const formatCompactNumber = (value) => {
+  const numberValue = Number(value || 0);
+  if (!Number.isFinite(numberValue)) return "0";
+  if (Math.abs(numberValue) < 1000) return formatInteger(numberValue);
+  return kCompactNumberFormatter.format(numberValue);
+};
+
 export const formatUsd = (value) => kUsdFormatter.format(Number(value || 0));
 
 export const formatLocaleDateTime = (

package/lib/server/auth-profiles.js

@@ -1,62 +1,216 @@
 const fs = require("fs");
 const path = require("path");
-const { AUTH_PROFILES_PATH, CODEX_PROFILE_ID } = require("./constants");
+const { AUTH_PROFILES_PATH, CODEX_PROFILE_ID, OPENCLAW_DIR } = require("./constants");
 
-const createAuthProfiles = () => {
-  const ensureAuthProfilesStore = () => {
-    let store = { version: 1, profiles: {} };
-    try {
-      if (fs.existsSync(AUTH_PROFILES_PATH)) {
-        const parsed = JSON.parse(fs.readFileSync(AUTH_PROFILES_PATH, "utf8"));
-        if (
-          parsed &&
-          typeof parsed === "object" &&
-          parsed.profiles &&
-          typeof parsed.profiles === "object"
-        ) {
-          store = {
-            version: Number(parsed.version || 1),
-            profiles: parsed.profiles,
-            order: parsed.order,
-            lastGood: parsed.lastGood,
-            usageStats: parsed.usageStats,
-          };
-        }
+const kDefaultAgentId = "main";
+
+const normalizeSecret = (raw) =>
+  String(raw ?? "")
+    .replace(/[\r\n\u2028\u2029]/g, "")
+    .trim();
+
+const credentialMode = (credential) => {
+  if (credential.type === "api_key") return "api_key";
+  if (credential.type === "token") return "token";
+  return "oauth";
+};
+
+const resolveAgentDir = (agentId = kDefaultAgentId) =>
+  path.join(OPENCLAW_DIR, "agents", agentId, "agent");
+
+const resolveAuthProfilesPath = (agentId = kDefaultAgentId) =>
+  path.join(resolveAgentDir(agentId), "auth-profiles.json");
+
+const resolveOpenclawConfigPath = () =>
+  path.join(OPENCLAW_DIR, "openclaw.json");
+
+const loadAuthStore = (agentId = kDefaultAgentId) => {
+  const storePath = resolveAuthProfilesPath(agentId);
+  let store = { version: 1, profiles: {} };
+  try {
+    if (fs.existsSync(storePath)) {
+      const parsed = JSON.parse(fs.readFileSync(storePath, "utf8"));
+      if (
+        parsed &&
+        typeof parsed === "object" &&
+        parsed.profiles &&
+        typeof parsed.profiles === "object"
+      ) {
+        store = {
+          version: Number(parsed.version || 1),
+          profiles: parsed.profiles,
+          order: parsed.order,
+          lastGood: parsed.lastGood,
+          usageStats: parsed.usageStats,
+        };
       }
-    } catch {}
-    return store;
+    }
+  } catch {}
+  return store;
+};
+
+const saveAuthStore = (agentId, store) => {
+  const storePath = resolveAuthProfilesPath(agentId);
+  fs.mkdirSync(path.dirname(storePath), { recursive: true });
+  fs.writeFileSync(
+    storePath,
+    JSON.stringify(
+      {
+        version: Number(store.version || 1),
+        profiles: store.profiles || {},
+        ...(store.order !== undefined ? { order: store.order } : {}),
+        ...(store.lastGood !== undefined ? { lastGood: store.lastGood } : {}),
+        ...(store.usageStats !== undefined
+          ? { usageStats: store.usageStats }
+          : {}),
+      },
+      null,
+      2,
+    ),
+  );
+};
+
+const loadOpenclawConfig = () => {
+  const configPath = resolveOpenclawConfigPath();
+  try {
+    return JSON.parse(fs.readFileSync(configPath, "utf8"));
+  } catch {
+    return {};
+  }
+};
+
+const saveOpenclawConfig = (cfg) => {
+  const configPath = resolveOpenclawConfigPath();
+  fs.writeFileSync(configPath, JSON.stringify(cfg, null, 2));
+};
+
+const syncConfigAuthReference = (cfg, profileId, credential) => {
+  const next = { ...cfg };
+  if (!next.auth) next.auth = {};
+  if (!next.auth.profiles) next.auth.profiles = {};
+  next.auth = { ...next.auth, profiles: { ...next.auth.profiles } };
+  next.auth.profiles[profileId] = {
+    provider: credential.provider,
+    mode: credentialMode(credential),
   };
+  return next;
+};
 
-  const saveAuthProfilesStore = (store) => {
-    fs.mkdirSync(path.dirname(AUTH_PROFILES_PATH), { recursive: true });
-    fs.writeFileSync(
-      AUTH_PROFILES_PATH,
-      JSON.stringify(
-        {
-          version: Number(store.version || 1),
-          profiles: store.profiles || {},
-          order: store.order,
-          lastGood: store.lastGood,
-          usageStats: store.usageStats,
-        },
-        null,
-        2,
-      ),
-    );
+const removeConfigAuthReference = (cfg, profileId) => {
+  if (!cfg.auth?.profiles?.[profileId]) return cfg;
+  const next = { ...cfg };
+  next.auth = { ...next.auth, profiles: { ...next.auth.profiles } };
+  delete next.auth.profiles[profileId];
+  if (Object.keys(next.auth.profiles).length === 0) {
+    delete next.auth.profiles;
+  }
+  if (Object.keys(next.auth).length === 0) {
+    delete next.auth;
+  }
+  return next;
+};
+
+const createAuthProfiles = () => {
+  // ── Generic profile operations ──
+
+  const listProfiles = (agentId = kDefaultAgentId) => {
+    const store = loadAuthStore(agentId);
+    return Object.entries(store.profiles || {}).map(([id, cred]) => ({
+      id,
+      ...cred,
+    }));
   };
 
-  const listCodexProfiles = () => {
-    const store = ensureAuthProfilesStore();
-    return Object.entries(store.profiles || {})
-      .filter(([, cred]) => cred?.provider === "openai-codex")
-      .map(([id, cred]) => ({ id, cred }));
+  const listProfilesByProvider = (provider, agentId = kDefaultAgentId) =>
+    listProfiles(agentId).filter((p) => p.provider === provider);
+
+  const getProfile = (profileId, agentId = kDefaultAgentId) => {
+    const store = loadAuthStore(agentId);
+    const cred = store.profiles?.[profileId];
+    if (!cred) return null;
+    return { id: profileId, ...cred };
   };
 
+  const upsertProfile = (profileId, credential, agentId = kDefaultAgentId) => {
+    const store = loadAuthStore(agentId);
+    const sanitized = { ...credential };
+    if (sanitized.key) sanitized.key = normalizeSecret(sanitized.key);
+    if (sanitized.token) sanitized.token = normalizeSecret(sanitized.token);
+    if (sanitized.access) sanitized.access = normalizeSecret(sanitized.access);
+    if (sanitized.refresh)
+      sanitized.refresh = normalizeSecret(sanitized.refresh);
+    store.profiles[profileId] = sanitized;
+    saveAuthStore(agentId, store);
+
+    const cfg = loadOpenclawConfig();
+    const updated = syncConfigAuthReference(cfg, profileId, sanitized);
+    saveOpenclawConfig(updated);
+  };
+
+  const removeProfile = (profileId, agentId = kDefaultAgentId) => {
+    const store = loadAuthStore(agentId);
+    if (!store.profiles[profileId]) return false;
+    delete store.profiles[profileId];
+    saveAuthStore(agentId, store);
+
+    const cfg = loadOpenclawConfig();
+    const updated = removeConfigAuthReference(cfg, profileId);
+    saveOpenclawConfig(updated);
+    return true;
+  };
+
+  const setAuthOrder = (provider, orderedProfileIds, agentId = kDefaultAgentId) => {
+    const store = loadAuthStore(agentId);
+    if (!store.order) store.order = {};
+    store.order[provider] = orderedProfileIds;
+    saveAuthStore(agentId, store);
+  };
+
+  const syncConfigAuthReferencesForAgent = (agentId = kDefaultAgentId) => {
+    const store = loadAuthStore(agentId);
+    let cfg = loadOpenclawConfig();
+    for (const [profileId, credential] of Object.entries(store.profiles || {})) {
+      if (!credential?.type || !credential?.provider) continue;
+      cfg = syncConfigAuthReference(cfg, profileId, credential);
+    }
+    saveOpenclawConfig(cfg);
+  };
+
+  // ── Model config operations ──
+
+  const getModelConfig = () => {
+    const cfg = loadOpenclawConfig();
+    const defaults = cfg.agents?.defaults || {};
+    return {
+      primary: defaults.model?.primary || null,
+      configuredModels: defaults.models || {},
+    };
+  };
+
+  const setModelConfig = ({ primary, configuredModels }) => {
+    const cfg = loadOpenclawConfig();
+    if (!cfg.agents) cfg.agents = {};
+    if (!cfg.agents.defaults) cfg.agents.defaults = {};
+    if (!cfg.agents.defaults.model) cfg.agents.defaults.model = {};
+    if (primary !== undefined) {
+      cfg.agents.defaults.model.primary = primary;
+    }
+    if (configuredModels !== undefined) {
+      cfg.agents.defaults.models = configuredModels;
+    }
+    saveOpenclawConfig(cfg);
+  };
+
+  // ── Legacy Codex-specific wrappers ──
+
+  const listCodexProfiles = () => listProfilesByProvider("openai-codex");
+
   const getCodexProfile = () => {
     const profiles = listCodexProfiles();
     if (profiles.length === 0) return null;
-    const preferred = profiles.find((p) => p.id === CODEX_PROFILE_ID) || profiles[0];
-    return { profileId: preferred.id, ...preferred.cred };
+    const preferred =
+      profiles.find((p) => p.id === CODEX_PROFILE_ID) || profiles[0];
+    return { profileId: preferred.id, ...preferred };
   };
 
   const hasCodexOauthProfile = () => {
@@ -65,20 +219,18 @@ const createAuthProfiles = () => {
   };
 
   const upsertCodexProfile = ({ access, refresh, expires, accountId }) => {
-    const store = ensureAuthProfilesStore();
-    store.profiles[CODEX_PROFILE_ID] = {
+    upsertProfile(CODEX_PROFILE_ID, {
       type: "oauth",
       provider: "openai-codex",
       access,
       refresh,
       expires,
       ...(accountId ? { accountId } : {}),
-    };
-    saveAuthProfilesStore(store);
+    });
   };
 
   const removeCodexProfiles = () => {
-    const store = ensureAuthProfilesStore();
+    const store = loadAuthStore();
     let changed = false;
     for (const [id, cred] of Object.entries(store.profiles || {})) {
       if (cred?.provider === "openai-codex") {
@@ -86,15 +238,34 @@ const createAuthProfiles = () => {
         changed = true;
       }
     }
-    if (changed) saveAuthProfilesStore(store);
+    if (changed) {
+      saveAuthStore(kDefaultAgentId, store);
+      let cfg = loadOpenclawConfig();
+      for (const [id, cred] of Object.entries(cfg.auth?.profiles || {})) {
+        if (cred?.provider === "openai-codex") {
+          cfg = removeConfigAuthReference(cfg, id);
+        }
+      }
+      saveOpenclawConfig(cfg);
+    }
     return changed;
   };
 
   return {
+    listProfiles,
+    listProfilesByProvider,
+    getProfile,
+    upsertProfile,
+    removeProfile,
+    setAuthOrder,
+    syncConfigAuthReferencesForAgent,
+    getModelConfig,
+    setModelConfig,
     getCodexProfile,
     hasCodexOauthProfile,
     upsertCodexProfile,
     removeCodexProfiles,
+    loadAuthStore,
   };
 };
 

package/lib/server/gateway.js

@@ -1,7 +1,13 @@
 const { spawn, execSync } = require("child_process");
 const fs = require("fs");
 const net = require("net");
-const { OPENCLAW_DIR, GATEWAY_HOST, GATEWAY_PORT, kChannelDefs, kRootDir } = require("./constants");
+const {
+  OPENCLAW_DIR,
+  GATEWAY_HOST,
+  GATEWAY_PORT,
+  kChannelDefs,
+  kRootDir,
+} = require("./constants");
 
 let gatewayChild = null;
 let gatewayExitHandler = null;
@@ -11,7 +17,9 @@ let gatewayStderrTail = [];
 const expectedExitPids = new Set();
 
 const appendStderrTail = (chunk) => {
-  const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk ?? "");
+  const text = Buffer.isBuffer(chunk)
+    ? chunk.toString("utf8")
+    : String(chunk ?? "");
   for (const line of text.split("\n")) {
     const trimmed = line.trimEnd();
     if (!trimmed) continue;
@@ -76,7 +84,9 @@ const runGatewayCmd = (cmd) => {
 
 const launchGatewayProcess = () => {
   if (gatewayChild && gatewayChild.exitCode === null && !gatewayChild.killed) {
-    console.log("[alphaclaw] Managed gateway process already running — skipping launch");
+    console.log(
+      "[alphaclaw] Managed gateway process already running — skipping launch",
+    );
     return gatewayChild;
   }
   gatewayStderrTail = [];
@@ -145,20 +155,24 @@ const restartGateway = (reloadEnv) => {
       gatewayChild.kill("SIGTERM");
       gatewayChild = null;
     } catch (e) {
-      console.log(`[alphaclaw] Failed to stop managed gateway process: ${e.message}`);
+      console.log(
+        `[alphaclaw] Failed to stop managed gateway process: ${e.message}`,
+      );
       runGatewayCmd("stop");
     }
   } else {
     runGatewayCmd("stop");
   }
-  runGatewayCmd("install --force");
+  runGatewayCmd("start");
   const launchWhenReady = async () => {
     const waitUntil = Date.now() + 8000;
     while (Date.now() < waitUntil) {
       if (!(await isGatewayRunning())) break;
       await new Promise((resolve) => setTimeout(resolve, 250));
     }
-    console.log("[alphaclaw] Starting openclaw gateway with refreshed environment...");
+    console.log(
+      "[alphaclaw] Starting openclaw gateway with refreshed environment...",
+    );
     launchGatewayProcess();
   };
   void launchWhenReady();
@@ -275,7 +289,9 @@ const syncChannelConfig = (savedVars, mode = "all") => {
 
 const getChannelStatus = () => {
   try {
-    const config = JSON.parse(fs.readFileSync(`${OPENCLAW_DIR}/openclaw.json`, "utf8"));
+    const config = JSON.parse(
+      fs.readFileSync(`${OPENCLAW_DIR}/openclaw.json`, "utf8"),
+    );
     const credDir = `${OPENCLAW_DIR}/credentials`;
     const channels = {};
 
@@ -287,9 +303,13 @@ const getChannelStatus = () => {
       try {
         const files = fs
           .readdirSync(credDir)
-          .filter((f) => f.startsWith(`${ch}-`) && f.endsWith("-allowFrom.json"));
+          .filter(
+            (f) => f.startsWith(`${ch}-`) && f.endsWith("-allowFrom.json"),
+          );
         for (const file of files) {
-          const data = JSON.parse(fs.readFileSync(`${credDir}/${file}`, "utf8"));
+          const data = JSON.parse(
+            fs.readFileSync(`${credDir}/${file}`, "utf8"),
+          );
           paired += (data.allowFrom || []).length;
         }
       } catch {}

package/lib/server/routes/models.js

@@ -1,6 +1,27 @@
 const { kFallbackOnboardingModels } = require("../constants");
 
-const registerModelRoutes = ({ app, shellCmd, gatewayEnv, parseJsonFromNoisyOutput, normalizeOnboardingModels }) => {
+const runModelsGitSync = async (shellCmd) => {
+  if (typeof shellCmd !== "function") return null;
+  try {
+    await shellCmd('alphaclaw git-sync -m "models: update config" -f "openclaw.json"', {
+      timeout: 30000,
+    });
+    return null;
+  } catch (err) {
+    return err?.message || "alphaclaw git-sync failed";
+  }
+};
+
+const registerModelRoutes = ({
+  app,
+  shellCmd,
+  gatewayEnv,
+  parseJsonFromNoisyOutput,
+  normalizeOnboardingModels,
+  authProfiles,
+}) => {
+  // ── Existing CLI-backed catalog/status routes ──
+
   app.get("/api/models", async (req, res) => {
     try {
       const output = await shellCmd("openclaw models list --all --json", {
@@ -60,7 +81,154 @@ const registerModelRoutes = ({ app, shellCmd, gatewayEnv, parseJsonFromNoisyOutp
       });
       res.json({ ok: true });
     } catch (err) {
-      res.status(400).json({ ok: false, error: err.message || "Failed to set model" });
+      res
+        .status(400)
+        .json({ ok: false, error: err.message || "Failed to set model" });
+    }
+  });
+
+  // ── Model config (direct JSON) ──
+
+  app.get("/api/models/config", (req, res) => {
+    try {
+      const { primary, configuredModels } = authProfiles.getModelConfig();
+      const agentId = req.query.agentId || undefined;
+      const profiles = authProfiles.listProfiles(agentId);
+      const store = authProfiles.loadAuthStore(agentId);
+      res.json({
+        ok: true,
+        primary,
+        configuredModels,
+        authProfiles: profiles,
+        authOrder: store.order || {},
+      });
+    } catch (err) {
+      res
+        .status(500)
+        .json({ ok: false, error: err.message || "Failed to read config" });
+    }
+  });
+
+  app.put("/api/models/config", async (req, res) => {
+    const { primary, configuredModels, profiles, authOrder } = req.body || {};
+    const agentId = req.query.agentId || undefined;
+    if (primary !== undefined && (typeof primary !== "string" || !primary.includes("/"))) {
+      return res
+        .status(400)
+        .json({ ok: false, error: "Invalid primary model key" });
+    }
+    if (
+      configuredModels !== undefined &&
+      (typeof configuredModels !== "object" || configuredModels === null)
+    ) {
+      return res
+        .status(400)
+        .json({ ok: false, error: "Invalid configuredModels" });
+    }
+    try {
+      authProfiles.setModelConfig({ primary, configuredModels });
+
+      if (Array.isArray(profiles)) {
+        for (const { id: profileId, ...credential } of profiles) {
+          if (profileId && credential.type && credential.provider) {
+            authProfiles.upsertProfile(profileId, credential, agentId);
+          }
+        }
+      }
+
+      if (authOrder && typeof authOrder === "object") {
+        for (const [provider, order] of Object.entries(authOrder)) {
+          if (Array.isArray(order)) {
+            authProfiles.setAuthOrder(provider, order, agentId);
+          }
+        }
+      }
+
+      // `auth-profiles.json` is the durable source of truth. Re-sync
+      // `openclaw.json.auth.profiles` on save so model re-adds restore refs.
+      authProfiles.syncConfigAuthReferencesForAgent(agentId);
+
+      const syncWarning = await runModelsGitSync(shellCmd);
+      res.json({
+        ok: true,
+        ...(syncWarning ? { syncWarning } : {}),
+      });
+    } catch (err) {
+      res
+        .status(500)
+        .json({ ok: false, error: err.message || "Failed to save config" });
+    }
+  });
+
+  // ── Auth profiles (direct JSON) ──
+
+  app.get("/api/models/auth", (req, res) => {
+    try {
+      const agentId = req.query.agentId || undefined;
+      const profiles = authProfiles.listProfiles(agentId);
+      const store = authProfiles.loadAuthStore(agentId);
+      res.json({ ok: true, profiles, order: store.order || {} });
+    } catch (err) {
+      res
+        .status(500)
+        .json({
+          ok: false,
+          error: err.message || "Failed to read auth profiles",
+        });
+    }
+  });
+
+  app.put("/api/models/auth/:profileId", (req, res) => {
+    const { profileId } = req.params;
+    const credential = req.body;
+    if (
+      !profileId ||
+      !credential?.type ||
+      !credential?.provider
+    ) {
+      return res
+        .status(400)
+        .json({ ok: false, error: "Missing profileId, type, or provider" });
+    }
+    const validTypes = new Set(["api_key", "token", "oauth"]);
+    if (!validTypes.has(credential.type)) {
+      return res.status(400).json({
+        ok: false,
+        error: `Invalid credential type: ${credential.type}`,
+      });
+    }
+    try {
+      const agentId = req.query.agentId || undefined;
+      authProfiles.upsertProfile(profileId, credential, agentId);
+      res.json({ ok: true });
+    } catch (err) {
+      res
+        .status(500)
+        .json({
+          ok: false,
+          error: err.message || "Failed to save auth profile",
+        });
+    }
+  });
+
+  app.delete("/api/models/auth/:profileId", (req, res) => {
+    const { profileId } = req.params;
+    if (!profileId) {
+      return res
+        .status(400)
+        .json({ ok: false, error: "Missing profileId" });
+    }
+    try {
+      const agentId = req.query.agentId || undefined;
+      const removed = authProfiles.removeProfile(profileId, agentId);
+      res.json({ ok: true, removed });
+    } catch (err) {
+      res
+        .status(500)
+        .json({
+          ok: false,
+          error: err.message || "Failed to remove auth profile",
+        });
     }
   });
 };