@chrysb/alphaclaw 0.9.9 → 0.9.10

package/lib/server/commands.js

@@ -20,8 +20,11 @@ const createCommands = ({ gatewayEnv }) => {
       );
       exec(cmd, { timeout: timeoutMs, ...execOpts }, (err, stdout, stderr) => {
         if (err) {
+          err.stdout = String(stdout || "").trim();
+          err.stderr = String(stderr || "").trim();
+          err.cmd = cmd;
           console.error(
-            `[onboard] Error: ${(stderr || err.message).slice(0, 300)}`,
+            `[onboard] Error: ${String(stderr || err.message || "").slice(0, 300)}`,
           );
           return reject(err);
         }

package/lib/server/constants.js

@@ -91,6 +91,11 @@ const kOnboardingModelProviders = new Set([
   "vllm",
 ]);
 const kFallbackOnboardingModels = [
+  {
+    key: "anthropic/claude-opus-4-7",
+    provider: "anthropic",
+    label: "Claude Opus 4.7",
+  },
   {
     key: "anthropic/claude-opus-4-6",
     provider: "anthropic",

package/lib/server/cost-utils.js

@@ -5,7 +5,16 @@ const kTokensPerMillion = 1_000_000;
 const kLongContextThresholdTokens = 200_000;
 const kNodeModulesPricingCacheTtlMs = 60_000;
 
+const kClaudeOpus47Pricing = {
+  input: 5.0,
+  output: 25.0,
+  cacheRead: 0.5,
+  cacheWrite: 6.25,
+};
+
 const kGlobalModelPricing = {
+  "claude-opus-4-7": kClaudeOpus47Pricing,
+  "claude-opus-4.7": kClaudeOpus47Pricing,
   "claude-opus-4-6": {
     input: (tokens) => (tokens > kLongContextThresholdTokens ? 10.0 : 5.0),
     output: (tokens) => (tokens > kLongContextThresholdTokens ? 37.5 : 25.0),

package/lib/server/cron-service.js

@@ -485,6 +485,16 @@ const parseCommandJson = (rawOutput) => {
   return null;
 };
 
+const resolvePromptEditFlag = ({ cronDir, jobId }) => {
+  const store = readCronStore({ cronDir });
+  const job = store.jobs.find((entry) => String(entry?.id || "") === jobId);
+  if (!job) throw new Error(`unknown cron job id: ${jobId}`);
+  const payloadKind = String(job?.payload?.kind || "").trim();
+  if (payloadKind === "systemEvent") return "--system-event";
+  if (payloadKind === "agentTurn") return "--message";
+  throw new Error(`unsupported cron payload kind: ${payloadKind || "unknown"}`);
+};
+
 const createCronService = ({
   clawCmd,
   OPENCLAW_DIR,
@@ -548,7 +558,8 @@ const createCronService = ({
 
   const updateJobPrompt = async ({ jobId, message }) => {
     const safeJobId = sanitizeCronJobId(jobId);
-    const command = `cron edit ${shellEscapeArg(safeJobId)} --message ${shellEscapeArg(message || "")}`;
+    const promptFlag = resolvePromptEditFlag({ cronDir, jobId: safeJobId });
+    const command = `cron edit ${shellEscapeArg(safeJobId)} ${promptFlag} ${shellEscapeArg(message || "")}`;
     return runCommand(command, { timeoutMs: 60000 });
   };
 

package/lib/server/db/doctor/index.js

@@ -18,6 +18,13 @@ const ensureDb = () => {
   return db;
 };
 
+const closeDoctorDb = () => {
+  if (!db) return;
+  const database = db;
+  db = null;
+  database.close();
+};
+
 const parseJsonText = (value, fallbackValue) => {
   if (typeof value !== "string" || !value) return fallbackValue;
   try {
@@ -171,6 +178,7 @@ const toRunModel = (row) => {
 };
 
 const initDoctorDb = ({ rootDir }) => {
+  closeDoctorDb();
   const dbDir = path.join(rootDir, "db");
   fs.mkdirSync(dbDir, { recursive: true });
   const dbPath = path.join(dbDir, "doctor.db");
@@ -511,6 +519,7 @@ const updateDoctorCardStatus = ({ id, status }) => {
 
 module.exports = {
   initDoctorDb,
+  closeDoctorDb,
   markIncompleteRunsFailed,
   getDoctorMeta,
   setDoctorMeta,

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

@@ -15,7 +15,19 @@ const ensureDb = () => {
   return db;
 };
 
+const closeUsageDb = () => {
+  if (!db) {
+    usageDbPath = "";
+    return;
+  }
+  const database = db;
+  db = null;
+  usageDbPath = "";
+  database.close();
+};
+
 const initUsageDb = ({ rootDir }) => {
+  closeUsageDb();
   const dbDir = path.join(rootDir, "db");
   fs.mkdirSync(dbDir, { recursive: true });
   usageDbPath = path.join(dbDir, "usage.db");
@@ -155,6 +167,7 @@ const getSessionUsageByKeyPattern = ({ keyPattern = "", sinceMs = 0 } = {}) => {
 
 module.exports = {
   initUsageDb,
+  closeUsageDb,
   getDailySummary: (options = {}) => getDailySummary({ database: ensureDb(), ...options }),
   getSessionsList: (options = {}) => getSessionsList({ database: ensureDb(), ...options }),
   getSessionDetail: (options = {}) => getSessionDetail({ database: ensureDb(), ...options }),

package/lib/server/db/watchdog/index.js

@@ -15,14 +15,25 @@ const ensureDb = () => {
   return db;
 };
 
+const closeWatchdogDb = () => {
+  if (pruneTimer) {
+    clearInterval(pruneTimer);
+    pruneTimer = null;
+  }
+  if (!db) return;
+  const database = db;
+  db = null;
+  database.close();
+};
+
 const initWatchdogDb = ({ rootDir, pruneDays = 30 }) => {
+  closeWatchdogDb();
   const dbDir = path.join(rootDir, "db");
   fs.mkdirSync(dbDir, { recursive: true });
   const dbPath = path.join(dbDir, "watchdog.db");
   db = new DatabaseSync(dbPath);
   createSchema(db);
   pruneWatchdogEvents(pruneDays);
-  if (pruneTimer) clearInterval(pruneTimer);
   pruneTimer = setInterval(() => {
     try {
       pruneWatchdogEvents(pruneDays);
@@ -125,6 +136,7 @@ const pruneWatchdogEvents = (days = 30) => {
 
 module.exports = {
   initWatchdogDb,
+  closeWatchdogDb,
   insertWatchdogEvent,
   getRecentEvents,
   pruneWatchdogEvents,

package/lib/server/db/webhooks/index.js

@@ -17,14 +17,25 @@ const ensureDb = () => {
   return db;
 };
 
+const closeWebhooksDb = () => {
+  if (pruneTimer) {
+    clearInterval(pruneTimer);
+    pruneTimer = null;
+  }
+  if (!db) return;
+  const database = db;
+  db = null;
+  database.close();
+};
+
 const initWebhooksDb = ({ rootDir, pruneDays = 30 }) => {
+  closeWebhooksDb();
   const dbDir = path.join(rootDir, "db");
   fs.mkdirSync(dbDir, { recursive: true });
   const dbPath = path.join(dbDir, "webhooks.db");
   db = new DatabaseSync(dbPath);
   createSchema(db);
   pruneOldEntries(pruneDays);
-  if (pruneTimer) clearInterval(pruneTimer);
   pruneTimer = setInterval(() => {
     try {
       pruneOldEntries(pruneDays);
@@ -413,6 +424,7 @@ const pruneOldEntries = (days = 30) => {
 
 module.exports = {
   initWebhooksDb,
+  closeWebhooksDb,
   insertRequest,
   getRequests,
   getRequestById,

package/lib/server/init/register-server-routes.js

@@ -97,6 +97,8 @@ const registerServerRoutes = ({
     gatewayEnv,
     parseJsonFromNoisyOutput,
     normalizeOnboardingModels,
+    readOpenclawVersion: (options) =>
+      openclawVersionService?.readOpenclawVersion(options),
     authProfiles,
     readEnvFile,
     writeEnvFile,

package/lib/server/internal-files-migration.js

@@ -9,6 +9,16 @@ const kOpenclawGitignoreHookEntries = [
   "!hooks/transforms/**",
 ];
 
+const kOpenclawGitignoreCronRuntimeEntries = [
+  "# OpenClaw cron runtime state (local only; job definitions stay in cron/jobs.json)",
+  "cron/jobs-state.json",
+];
+
+const kOpenclawGitignoreAppendEntries = [
+  ...kOpenclawGitignoreHookEntries,
+  ...kOpenclawGitignoreCronRuntimeEntries,
+];
+
 const buildManagedPaths = ({ openclawDir, pathModule = path }) => {
   const internalDir = pathModule.join(openclawDir, kInternalDirName);
   return {
@@ -89,7 +99,7 @@ const migrateManagedInternalFiles = ({
       const raw = String(fs.readFileSync(gitignorePath, "utf8") || "");
       const existingLines = raw.split(/\r?\n/);
       const existingSet = new Set(existingLines.map((line) => line.trim()));
-      const missing = kOpenclawGitignoreHookEntries.filter(
+      const missing = kOpenclawGitignoreAppendEntries.filter(
         (line) => !existingSet.has(line),
       );
       if (missing.length) {

package/lib/server/model-catalog-cache.js

@@ -1,6 +1,7 @@
 const fs = require("fs");
 const path = require("path");
 const { ALPHACLAW_DIR, kFallbackOnboardingModels } = require("./constants");
+const { getCommandOutputCandidates } = require("./utils/command-output");
 
 const kModelCatalogCacheVersion = 1;
 const kModelCatalogRefreshBackoffMs = 30 * 1000;
@@ -21,6 +22,12 @@ const createResponse = ({
   models,
 });
 
+const normalizeOpenclawVersion = (value) => {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized || null;
+};
+
 const normalizeCachedModels = ({
   models,
   normalizeOnboardingModels = (items) => items,
@@ -48,10 +55,20 @@ const normalizeCacheEntry = ({
   return {
     version: kModelCatalogCacheVersion,
     fetchedAt,
+    openclawVersion: normalizeOpenclawVersion(raw.openclawVersion),
     models,
   };
 };
 
+const parseCatalogModelsFromOutput = ({
+  rawOutput,
+  parseJsonFromNoisyOutput = () => ({}),
+  normalizeOnboardingModels = (items) => items,
+} = {}) => {
+  const parsed = parseJsonFromNoisyOutput(rawOutput);
+  return normalizeOnboardingModels(parsed?.models || []);
+};
+
 const createModelCatalogCache = ({
   fsModule = fs,
   pathModule = path,
@@ -59,6 +76,7 @@ const createModelCatalogCache = ({
   gatewayEnv = () => ({}),
   parseJsonFromNoisyOutput = () => ({}),
   normalizeOnboardingModels = (items) => items,
+  readOpenclawVersion = () => null,
   fallbackModels = kFallbackOnboardingModels,
   cachePath = kDefaultCachePath,
   refreshBackoffMs = kModelCatalogRefreshBackoffMs,
@@ -74,6 +92,23 @@ const createModelCatalogCache = ({
   let retryTimer = null;
   let backoffUntilMs = 0;
 
+  const readCurrentOpenclawVersion = ({ refresh = false } = {}) => {
+    try {
+      return normalizeOpenclawVersion(readOpenclawVersion({ refresh }));
+    } catch {
+      return null;
+    }
+  };
+
+  const isCompatibleWithCurrentOpenclaw = ({
+    entry,
+    currentOpenclawVersion,
+  } = {}) => {
+    if (!entry) return false;
+    if (!currentOpenclawVersion) return true;
+    return entry.openclawVersion === currentOpenclawVersion;
+  };
+
   const clearRetryTimer = () => {
     if (!retryTimer) return;
     clearTimeoutFn(retryTimer);
@@ -121,22 +156,51 @@ const createModelCatalogCache = ({
   };
 
   const loadFreshCatalog = async () => {
-    const output = await shellCmd("openclaw models list --all --json", {
-      env: gatewayEnv(),
-      timeout: 30000,
-    });
-    const parsed = parseJsonFromNoisyOutput(output);
-    const models = normalizeOnboardingModels(parsed?.models || []);
+    const openclawVersion = readCurrentOpenclawVersion({ refresh: true });
+    let models = [];
+    let recoveredFromCommandError = false;
+    try {
+      const output = await shellCmd("openclaw models list --all --json", {
+        env: gatewayEnv(),
+        timeout: 30000,
+      });
+      models = parseCatalogModelsFromOutput({
+        rawOutput: output,
+        parseJsonFromNoisyOutput,
+        normalizeOnboardingModels,
+      });
+    } catch (err) {
+      for (const rawOutput of getCommandOutputCandidates(err)) {
+        models = parseCatalogModelsFromOutput({
+          rawOutput,
+          parseJsonFromNoisyOutput,
+          normalizeOnboardingModels,
+        });
+        if (models.length > 0) {
+          recoveredFromCommandError = true;
+          logger.warn?.(
+            `[models] Recovered model catalog from failed command output: ${err.message || String(err)}`,
+          );
+          break;
+        }
+      }
+      if (models.length === 0) throw err;
+    }
     if (models.length === 0) {
       throw new Error("No models found");
     }
     const entry = {
       version: kModelCatalogCacheVersion,
       fetchedAt: now(),
+      openclawVersion,
       models,
     };
     writeDiskCache(entry);
     setCacheEntry(entry, { fresh: true });
+    if (recoveredFromCommandError) {
+      backoffUntilMs = 0;
+      clearRetryTimer();
+    }
     return entry;
   };
 
@@ -190,6 +254,21 @@ const createModelCatalogCache = ({
   return {
     async getCatalogResponse() {
       readDiskCache();
+      if (memoryCache && !cacheIsStale) {
+        const currentOpenclawVersion = readCurrentOpenclawVersion({
+          refresh: true,
+        });
+        if (
+          !isCompatibleWithCurrentOpenclaw({
+            entry: memoryCache,
+            currentOpenclawVersion,
+          })
+        ) {
+          cacheIsStale = true;
+          backoffUntilMs = 0;
+          clearRetryTimer();
+        }
+      }
       if (memoryCache && !cacheIsStale) {
         return createResponse({
           source: "openclaw",

package/lib/server/onboarding/github.js

@@ -113,6 +113,42 @@ const findOwnedRepoByName = async ({
   return null;
 };
 
+const findAccessibleOrgByLogin = async ({ repoOwner, ghHeaders }) => {
+  const normalizedRepoOwner = String(repoOwner || "").trim().toLowerCase();
+  if (!normalizedRepoOwner) return null;
+
+  let nextUrl = "https://api.github.com/user/orgs?per_page=100&page=1";
+  while (nextUrl) {
+    const res = await fetch(nextUrl, { headers: ghHeaders });
+    if (!res.ok) {
+      const details = await parseGithubErrorMessage(res);
+      return {
+        error:
+          `Cannot verify organization "${repoOwner}" access: ${details}. ` +
+          "Check the owner name or use a token that can access that organization.",
+      };
+    }
+
+    const orgs = await res.json();
+    if (!Array.isArray(orgs)) {
+      return {
+        error: `Cannot verify organization "${repoOwner}" access from GitHub response.`,
+      };
+    }
+
+    const org = orgs.find(
+      (item) =>
+        String(item?.login || "").trim().toLowerCase() ===
+        normalizedRepoOwner,
+    );
+    if (org) return { org };
+
+    nextUrl = getNextGithubPageUrl(res.headers?.get?.("link"));
+  }
+
+  return null;
+};
+
 const isClassicPat = (token) => String(token || "").startsWith("ghp_");
 const isFineGrainedPat = (token) =>
   String(token || "").startsWith("github_pat_");
@@ -187,7 +223,43 @@ const verifyGithubRepoForOnboarding = async ({
           error: `Repository "${repoUrl}" not found. Check the repo name and token permissions.`,
         };
       }
-      return { ok: true, repoExists: false, repoIsEmpty: false };
+      if (!viewerLogin) {
+        return {
+          ok: false,
+          status: 400,
+          error: "Cannot verify GitHub account owner for this token.",
+        };
+      }
+      if (repoOwner.toLowerCase() !== viewerLogin.toLowerCase()) {
+        const orgLookup = await findAccessibleOrgByLogin({
+          repoOwner,
+          ghHeaders,
+        });
+        if (!orgLookup?.org) {
+          return {
+            ok: false,
+            status: 400,
+            error:
+              orgLookup?.error ||
+              `Repository owner "${repoOwner}" does not match the authenticated GitHub user "${viewerLogin}" ` +
+                "and was not found in the token's accessible organizations. Check the owner name or use a token that can create repositories for that organization.",
+          };
+        }
+        return {
+          ok: true,
+          repoExists: false,
+          repoIsEmpty: false,
+          createOwnerType: "org",
+          viewerLogin,
+        };
+      }
+      return {
+        ok: true,
+        repoExists: false,
+        repoIsEmpty: false,
+        createOwnerType: "user",
+        viewerLogin,
+      };
     }
     if (checkRes.ok) {
       const commitsRes = await fetch(
@@ -250,6 +322,7 @@ const ensureGithubRepoAccessible = async ({
   githubToken,
 }) => {
   const ghHeaders = buildGithubHeaders(githubToken);
+  const [repoOwner = ""] = String(repoUrl || "").split("/");
   const verification = await verifyGithubRepoForOnboarding({
     repoUrl,
     githubToken,
@@ -262,7 +335,11 @@ const ensureGithubRepoAccessible = async ({
 
   try {
     console.log(`[onboard] Creating repo ${repoUrl}...`);
-    const createRes = await fetch("https://api.github.com/user/repos", {
+    const createUrl =
+      verification.createOwnerType === "org"
+        ? `https://api.github.com/orgs/${repoOwner}/repos`
+        : "https://api.github.com/user/repos";
+    const createRes = await fetch(createUrl, {
       method: "POST",
       headers: { ...ghHeaders, "Content-Type": "application/json" },
       body: JSON.stringify({

package/lib/server/openclaw-version.js

@@ -24,9 +24,10 @@ const createOpenclawVersionService = ({
   };
   let kOpenclawUpdateInProgress = false;
 
-  const readOpenclawVersion = () => {
+  const readOpenclawVersion = ({ refresh = false } = {}) => {
     const now = Date.now();
     if (
+      !refresh &&
       kOpenclawVersionCache.value &&
       now - kOpenclawVersionCache.fetchedAt < kVersionCacheTtlMs
     ) {

package/lib/server/routes/models.js

@@ -1,5 +1,6 @@
 const { kFallbackOnboardingModels } = require("../constants");
 const { createModelCatalogCache } = require("../model-catalog-cache");
+const { getCommandOutputCandidates } = require("../utils/command-output");
 
 const runModelsGitSync = async (shellCmd) => {
   if (typeof shellCmd !== "function") return null;
@@ -13,12 +14,24 @@ const runModelsGitSync = async (shellCmd) => {
   }
 };
 
+const parseJsonFromShellError = ({
+  error,
+  parseJsonFromNoisyOutput = () => null,
+} = {}) => {
+  for (const rawOutput of getCommandOutputCandidates(error)) {
+    const parsed = parseJsonFromNoisyOutput(rawOutput);
+    if (parsed) return parsed;
+  }
+  return null;
+};
+
 const registerModelRoutes = ({
   app,
   shellCmd,
   gatewayEnv,
   parseJsonFromNoisyOutput,
   normalizeOnboardingModels,
+  readOpenclawVersion,
   authProfiles,
   readEnvFile,
   writeEnvFile,
@@ -28,6 +41,7 @@ const registerModelRoutes = ({
     gatewayEnv,
     parseJsonFromNoisyOutput,
     normalizeOnboardingModels,
+    readOpenclawVersion,
     fallbackModels: kFallbackOnboardingModels,
   }),
 }) => {
@@ -180,6 +194,18 @@ const registerModelRoutes = ({
         imageModel: parsed.imageModel || null,
       });
     } catch (err) {
+      const parsed = parseJsonFromShellError({
+        error: err,
+        parseJsonFromNoisyOutput,
+      });
+      if (parsed) {
+        return res.json({
+          ok: true,
+          modelKey: parsed.resolvedDefault || parsed.defaultModel || null,
+          fallbacks: parsed.fallbacks || [],
+          imageModel: parsed.imageModel || null,
+        });
+      }
       res.json({
         ok: false,
         error: err.message || "Failed to read model status",