OpenClaw 2026.7.1-2 pin, watchdog lifecycle hardening, 99.6% test coverage

bin/alphaclaw.js

@@ -20,6 +20,7 @@ const {
   restoreMissingOpenclawConfigFromRemote,
 } = require("../lib/cli/openclaw-config-restore");
 const { buildSecretReplacements } = require("../lib/server/helpers");
+const { resolveSelfDependency } = require("../lib/server/self-dependency");
 const {
   migrateLegacyTelegramStreamingConfig,
 } = require("../lib/server/openclaw-config-migrations");
@@ -189,29 +190,34 @@ console.log(`[alphaclaw] Root directory: ${rootDir}`);
 // from the fresh container using the persistent volume marker.
 const pendingUpdateMarker = path.join(rootDir, ".alphaclaw-update-pending");
 if (fs.existsSync(pendingUpdateMarker)) {
-  console.log(
-    "[alphaclaw] Pending update detected, installing @chrysb/alphaclaw@latest...",
-  );
-  const alphaPkgRoot = path.resolve(__dirname, "..");
-  const nmIndex = alphaPkgRoot.lastIndexOf(
-    `${path.sep}node_modules${path.sep}`,
-  );
-  const installDir =
-    nmIndex >= 0 ? alphaPkgRoot.slice(0, nmIndex) : alphaPkgRoot;
-  try {
-    execSync(
-      "npm install @chrysb/alphaclaw@latest --omit=dev --prefer-online",
-      {
-        cwd: installDir,
-        stdio: "inherit",
-        timeout: 180000,
-      },
+  const selfDep = resolveSelfDependency({ fsImpl: fs });
+  if (selfDep.isGit) {
+    // Git-based installs update by redeploying (which reinstalls from the pinned
+    // ref), not by `npm install <pkg>@latest`. Clear the marker and move on.
+    console.log(
+      "[alphaclaw] Pending update marker found, but this install is git-based; updates apply on redeploy. Skipping npm install.",
     );
     fs.unlinkSync(pendingUpdateMarker);
-    console.log("[alphaclaw] Update applied successfully");
-  } catch (e) {
-    console.log(`[alphaclaw] Update install failed: ${e.message}`);
-    fs.unlinkSync(pendingUpdateMarker);
+  } else {
+    const selfUpdatePackageName = selfDep.key || "alphaclaw";
+    console.log(
+      `[alphaclaw] Pending update detected, installing ${selfUpdatePackageName}@latest...`,
+    );
+    try {
+      execSync(
+        `npm install ${selfUpdatePackageName}@latest --omit=dev --prefer-online`,
+        {
+          cwd: selfDep.installDir,
+          stdio: "inherit",
+          timeout: 180000,
+        },
+      );
+      fs.unlinkSync(pendingUpdateMarker);
+      console.log("[alphaclaw] Update applied successfully");
+    } catch (e) {
+      console.log(`[alphaclaw] Update install failed: ${e.message}`);
+      fs.unlinkSync(pendingUpdateMarker);
+    }
   }
 }
 
@@ -894,6 +900,22 @@ if (fs.existsSync(configPath)) {
       console.log("[alphaclaw] Discord added");
       changed = true;
     }
+    // Drop usage-tracker plugin paths left by a previous install location (e.g. a
+    // prior @chrysb/alphaclaw npm install at /app/node_modules/@chrysb/alphaclaw/...
+    // after switching to a git dependency at /app/node_modules/alphaclaw/...). The
+    // dead path makes OpenClaw reject the whole config. This block runs on every
+    // boot whenever a config exists — onboarded or not — so it is the migration's
+    // load-bearing prune; the onboarded reconcile prune is a backstop.
+    const usageTrackerPathPattern = /[\\/]plugin[\\/]usage-tracker[\\/]?$/;
+    const prunedPaths = cfg.plugins.load.paths.filter(
+      (entry) =>
+        entry === kUsageTrackerPluginPath ||
+        !usageTrackerPathPattern.test(String(entry || "")),
+    );
+    if (prunedPaths.length !== cfg.plugins.load.paths.length) {
+      cfg.plugins.load.paths = prunedPaths;
+      changed = true;
+    }
     if (!cfg.plugins.load.paths.includes(kUsageTrackerPluginPath)) {
       cfg.plugins.load.paths.push(kUsageTrackerPluginPath);
       changed = true;

lib/server.js

@@ -291,6 +291,7 @@ const watchdog = createWatchdog({
   reloadEnv,
   resolveSetupUrl,
   resolveGatewayHealthUrl: () => `${getGatewayUrl()}/health`,
+  resolveGatewayReadyzUrl: () => `${getGatewayUrl()}/readyz`,
 });
 const watchdogTerminal = createWatchdogTerminalService({
   cwd: constants.OPENCLAW_DIR,

lib/server/alphaclaw-version.js

@@ -14,14 +14,18 @@ const {
   normalizeOpenclawVersion,
   resolveGithubRepoUrl,
 } = require("./helpers");
+const {
+  resolveSelfDependency,
+  looksLikeGitDependency,
+} = require("./self-dependency");
 
 const kGithubApiBaseUrl = "https://api.github.com/repos";
 const kGithubRawBaseUrl = "https://raw.githubusercontent.com";
 const kDefaultTemplateBranch = "main";
 const kRailwayTemplateRepoUrl =
   "https://github.com/chrysb/openclaw-railway-template.git";
 const kRenderTemplateRepoUrl =
-  "https://github.com/chrysb/openclaw-render-template.git";
+  "https://github.com/garrytan/openclaw-render-template.git";
 const kApexTemplateRepoUrl =
   "https://github.com/chrysb/openclaw-apex-template.git";
 
@@ -91,10 +95,18 @@ const buildGithubHeaders = ({ env = process.env, accept = "application/json" } =
   return headers;
 };
 
-const extractTemplateVersions = (pkg) => ({
-  latestVersion: normalizeVersion(pkg?.dependencies?.["@chrysb/alphaclaw"]),
-  latestOpenclawVersion: normalizeOpenclawVersion(pkg?.dependencies?.openclaw),
-});
+const extractTemplateVersions = (pkg) => {
+  const alphaclawSpec =
+    pkg?.dependencies?.["alphaclaw"] || pkg?.dependencies?.["@chrysb/alphaclaw"];
+  return {
+    // A git-pinned template has no semver to compare against — report null so we
+    // never surface a bogus "update available" from a git URL string.
+    latestVersion: looksLikeGitDependency(alphaclawSpec)
+      ? null
+      : normalizeVersion(alphaclawSpec),
+    latestOpenclawVersion: normalizeOpenclawVersion(pkg?.dependencies?.openclaw),
+  };
+};
 
 const fetchLatestVersionFromRegistry = async ({ fetchImpl, version = null }) => {
   if (typeof fetchImpl !== "function") {
@@ -343,12 +355,33 @@ const detectUpdateStrategy = ({
     });
   }
 
+  // Git-based installs (e.g. `"alphaclaw": "git+https://github.com/<owner>/alphaclaw.git#main"`)
+  // can't be updated by `npm install <pkg>@latest` from the registry — updates come
+  // from pulling the source and reinstalling/redeploying. Keep the in-place npm
+  // self-update only when AlphaClaw is pinned to an npm version.
+  const selfDep = resolveSelfDependency({ fsImpl });
+  if (selfDep.isGit) {
+    return createUpdateStrategy({
+      action: "instructions",
+      provider: "git",
+      label: "Git source",
+      description:
+        "This AlphaClaw is installed from a git repository. Update by pulling the latest commit of your source repo and reinstalling (or redeploying), then restart AlphaClaw.",
+      steps: [
+        "Pull the latest commit of your AlphaClaw source repository",
+        "Reinstall dependencies so the new version is built (npm install)",
+        "Restart AlphaClaw to load the update",
+      ],
+      primaryActionLabel: "Done",
+    });
+  }
+
+  const selfUpdatePackageName = selfDep.key || "alphaclaw";
   return createUpdateStrategy({
     action: "self-update",
     provider: "self-hosted",
     label: "This install",
-    description:
-      "This will install the latest @chrysb/alphaclaw package in place and restart AlphaClaw.",
+    description: `This will install the latest ${selfUpdatePackageName} package in place and restart AlphaClaw.`,
     steps: [
       "AlphaClaw will install the latest published package in place",
       "The process will restart after the new files are copied into node_modules",
@@ -451,7 +484,9 @@ const createAlphaclawVersionService = ({
 
   const installLatestAlphaclaw = () =>
     new Promise((resolve, reject) => {
-      const installDir = findInstallDir(fsImpl);
+      const selfDep = resolveSelfDependency({ fsImpl });
+      const installDir = selfDep.installDir;
+      const selfUpdatePackageName = selfDep.key || "alphaclaw";
       const tmpDir = fsImpl.mkdtempSync(path.join(os.tmpdir(), "alphaclaw-update-"));
 
       const cleanup = () => {
@@ -464,7 +499,7 @@ const createAlphaclawVersionService = ({
         path.join(tmpDir, "package.json"),
         JSON.stringify({
           private: true,
-          dependencies: { "@chrysb/alphaclaw": "latest" },
+          dependencies: { [selfUpdatePackageName]: "latest" },
         }),
       );
 
@@ -476,7 +511,7 @@ const createAlphaclawVersionService = ({
       };
 
       console.log(
-        `[alphaclaw] Running: npm install @chrysb/alphaclaw@latest in temp dir (target: ${installDir})`,
+        `[alphaclaw] Running: npm install ${selfUpdatePackageName}@latest in temp dir (target: ${installDir})`,
       );
       childProcess.exec(
         "npm install --omit=dev --prefer-online --package-lock=false",
@@ -494,7 +529,7 @@ const createAlphaclawVersionService = ({
             cleanup();
             return reject(
               new Error(
-                message || "Failed to install @chrysb/alphaclaw@latest",
+                message || `Failed to install ${selfUpdatePackageName}@latest`,
               ),
             );
           }
@@ -616,6 +651,12 @@ const createAlphaclawVersionService = ({
   const getVersionStatus = async (refresh) => {
     const strategy = detectUpdateStrategy({ env, fsImpl });
     try {
+      if (strategy.provider === "git") {
+        // Git-sourced installs have no npm registry or template version to compare
+        // against — updates come from redeploying the pinned ref. Report current
+        // state without a remote version check.
+        return buildVersionStatus({ strategy });
+      }
       if (strategy.templateRepoUrl) {
         const status = await readTemplateStatus({
           repoUrl: strategy.templateRepoUrl,
@@ -719,35 +760,6 @@ const createAlphaclawVersionService = ({
   };
 };
 
-const findInstallDir = (fsImpl) => {
-  let dir = kNpmPackageRoot;
-  while (dir !== path.dirname(dir)) {
-    const parent = path.dirname(dir);
-    if (
-      path.basename(parent) === "node_modules" ||
-      parent.includes(`${path.sep}node_modules${path.sep}`)
-    ) {
-      dir = parent;
-      continue;
-    }
-    const pkgPath = path.join(parent, "package.json");
-    if (fsImpl.existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(fsImpl.readFileSync(pkgPath, "utf8"));
-        if (
-          pkg.dependencies?.["@chrysb/alphaclaw"] ||
-          pkg.devDependencies?.["@chrysb/alphaclaw"] ||
-          pkg.optionalDependencies?.["@chrysb/alphaclaw"]
-        ) {
-          return parent;
-        }
-      } catch {}
-    }
-    dir = parent;
-  }
-  return kNpmPackageRoot;
-};
-
 module.exports = {
   createAlphaclawVersionService,
   detectUpdateStrategy,

lib/server/constants.js

@@ -229,7 +229,7 @@ const kOpenclawUpdateCopyTimeoutMs = 5 * 60 * 1000;
 const kOpenclawRegistryUrl = "https://registry.npmjs.org/openclaw";
 const kAlphaclawRegistryUrl = "https://registry.npmjs.org/@chrysb%2falphaclaw";
 const kAlphaclawGithubReleasesBaseUrl =
-  "https://api.github.com/repos/chrysb/alphaclaw/releases";
+  "https://api.github.com/repos/garrytan/alphaclaw/releases";
 const kAppDir = kNpmPackageRoot;
 const kMaxPayloadBytes = parsePositiveInt(process.env.WEBHOOK_LOG_MAX_BYTES, 50 * 1024);
 const kWebhookPruneDays = parsePositiveInt(process.env.WEBHOOK_LOG_RETENTION_DAYS, 30);

lib/server/openclaw-version.js

@@ -10,6 +10,7 @@ const {
 } = require("./constants");
 const { normalizeOpenclawVersion } = require("./helpers");
 const { parseJsonObjectFromNoisyOutput } = require("./utils/json");
+const { resolveSelfDependency } = require("./self-dependency");
 const { assertSupportedNodeVersion } = require("../node-runtime");
 
 const createOpenclawVersionService = ({
@@ -89,35 +90,10 @@ const createOpenclawVersionService = ({
     }
   };
 
-  const findInstallDir = () => {
-    // Resolve the consumer app root (for example /app in Docker), not this package directory.
-    let dir = kNpmPackageRoot;
-    while (dir !== path.dirname(dir)) {
-      const parent = path.dirname(dir);
-      if (
-        path.basename(parent) === "node_modules" ||
-        parent.includes(`${path.sep}node_modules${path.sep}`)
-      ) {
-        dir = parent;
-        continue;
-      }
-      const pkgPath = path.join(parent, "package.json");
-      if (fs.existsSync(pkgPath)) {
-        try {
-          const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-          if (
-            pkg.dependencies?.["@chrysb/alphaclaw"] ||
-            pkg.devDependencies?.["@chrysb/alphaclaw"] ||
-            pkg.optionalDependencies?.["@chrysb/alphaclaw"]
-          ) {
-            return parent;
-          }
-        } catch {}
-      }
-      dir = parent;
-    }
-    return kNpmPackageRoot;
-  };
+  // Resolve the consumer app root (for example /app in Docker), not this package
+  // directory. Matches AlphaClaw under either the `alphaclaw` alias (git installs)
+  // or the `@chrysb/alphaclaw` npm scope.
+  const findInstallDir = () => resolveSelfDependency({ fsImpl: fs }).installDir;
 
   // Install to a temp directory, then copy into the real node_modules.
   // Running `npm install` directly in the app dir causes EBUSY on Docker

lib/server/routes/watchdog.js

@@ -51,6 +51,19 @@ const registerWatchdogRoutes = ({
     }
   });
 
+  app.post("/api/watchdog/resume-channels", requireAuth, async (req, res) => {
+    try {
+      const result = await watchdog.resumeChannels();
+      if (result?.skipped) {
+        res.status(409).json({ ok: false, error: result.reason, result });
+        return;
+      }
+      res.json({ ok: !!result?.ok, result });
+    } catch (err) {
+      res.status(500).json({ ok: false, error: err.message });
+    }
+  });
+
   app.get("/api/watchdog/settings", requireAuth, (req, res) => {
     try {
       res.json({ ok: true, settings: watchdog.getSettings() });