@chrysb/alphaclaw 0.1.1 → 0.1.3

package/bin/alphaclaw.js

@@ -13,16 +13,27 @@ const { execSync } = require("child_process");
 const args = process.argv.slice(2);
 const command = args.find((a) => !a.startsWith("-"));
 
+const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8"));
+
+if (args.includes("--version") || args.includes("-v") || command === "version") {
+  console.log(pkg.version);
+  process.exit(0);
+}
+
 if (!command || command === "help" || args.includes("--help")) {
   console.log(`
+alphaclaw v${pkg.version}
+
 Usage: alphaclaw <command> [options]
 
 Commands:
   start     Start the AlphaClaw server (Setup UI + gateway manager)
+  version   Print version
 
 Options:
   --root-dir <path>   Persistent data directory (default: ~/.alphaclaw)
   --port <number>     Server port (default: 3000)
+  --version, -v       Print version
   --help              Show this help message
 `);
   process.exit(0);

package/lib/public/js/components/gateway.js

@@ -3,102 +3,126 @@ import { useEffect, useState } from "https://esm.sh/preact/hooks";
 import htm from "https://esm.sh/htm";
 import {
   fetchOpenclawVersion,
+  fetchAlphaclawVersion,
   restartGateway,
   updateOpenclaw,
+  updateAlphaclaw,
 } from "../lib/api.js";
 import { showToast } from "./toast.js";
 const html = htm.bind(h);
 
-export function Gateway({ status, openclawVersion }) {
-  const [restarting, setRestarting] = useState(false);
-  const [checkingUpdate, setCheckingUpdate] = useState(false);
-  const [currentVersion, setCurrentVersion] = useState(openclawVersion || null);
+function VersionRow({ label, currentVersion, fetchVersion, applyUpdate, tagsUrl }) {
+  const [checking, setChecking] = useState(false);
+  const [version, setVersion] = useState(currentVersion || null);
   const [latestVersion, setLatestVersion] = useState(null);
   const [hasUpdate, setHasUpdate] = useState(false);
-  const [updateError, setUpdateError] = useState("");
-  const isRunning = status === "running" && !restarting;
-  const dotClass = isRunning
-    ? "w-2 h-2 rounded-full bg-green-500"
-    : "w-2 h-2 rounded-full bg-yellow-500 animate-pulse";
+  const [error, setError] = useState("");
 
   useEffect(() => {
-    setCurrentVersion(openclawVersion || null);
-  }, [openclawVersion]);
+    setVersion(currentVersion || null);
+  }, [currentVersion]);
 
   useEffect(() => {
     let active = true;
-    const loadLatest = async () => {
+    const load = async () => {
       try {
-        const data = await fetchOpenclawVersion(false);
+        const data = await fetchVersion(false);
         if (!active) return;
-        setCurrentVersion(data.currentVersion || openclawVersion || null);
+        setVersion(data.currentVersion || currentVersion || null);
         setLatestVersion(data.latestVersion || null);
         setHasUpdate(!!data.hasUpdate);
-        setUpdateError(data.ok ? "" : data.error || "");
+        setError(data.ok ? "" : data.error || "");
       } catch (err) {
         if (!active) return;
-        setUpdateError(err.message || "Could not check updates");
+        setError(err.message || "Could not check updates");
       }
     };
-    loadLatest();
-    return () => {
-      active = false;
-    };
+    load();
+    return () => { active = false; };
   }, []);
 
-  const handleRestart = async () => {
-    if (restarting) return;
-    setRestarting(true);
-    try {
-      await restartGateway();
-      showToast("Gateway restarted", "success");
-    } catch (err) {
-      showToast("Restart failed: " + err.message, "error");
-    }
-    setRestarting(false);
-  };
-
-  const handleUpdate = async () => {
-    if (checkingUpdate) return;
-    setCheckingUpdate(true);
-    setUpdateError("");
+  const handleAction = async () => {
+    if (checking) return;
+    setChecking(true);
+    setError("");
     try {
       const data = hasUpdate
-        ? await updateOpenclaw()
-        : await fetchOpenclawVersion(true);
-      setCurrentVersion(data.currentVersion || currentVersion);
+        ? await applyUpdate()
+        : await fetchVersion(true);
+      setVersion(data.currentVersion || version);
       setLatestVersion(data.latestVersion || null);
       setHasUpdate(!!data.hasUpdate);
-      setUpdateError(data.ok ? "" : data.error || "");
+      setError(data.ok ? "" : data.error || "");
       if (hasUpdate) {
         if (!data.ok) {
-          showToast(data.error || "OpenClaw update failed", "error");
-        } else if (data.updated) {
+          showToast(data.error || `${label} update failed`, "error");
+        } else if (data.updated || data.restarting) {
           showToast(
-            data.restarted
-              ? `Updated to ${data.currentVersion} and restarted gateway`
-              : `Updated to ${data.currentVersion}`,
+            data.restarting
+              ? `${label} updated — restarting...`
+              : `Updated ${label} to ${data.currentVersion}`,
             "success",
           );
         } else {
-          showToast("Already at latest OpenClaw version", "success");
+          showToast(`Already at latest ${label} version`, "success");
         }
       } else if (data.hasUpdate && data.latestVersion) {
-        showToast(`Update available: ${data.latestVersion}`, "warning");
+        showToast(`${label} update available: ${data.latestVersion}`, "warning");
       } else {
-        showToast("OpenClaw is up to date", "success");
+        showToast(`${label} is up to date`, "success");
       }
     } catch (err) {
-      setUpdateError(
-        err.message ||
-          (hasUpdate ? "Could not update OpenClaw" : "Could not check updates"),
-      );
-      showToast(
-        hasUpdate ? "Could not update OpenClaw" : "Could not check updates",
-        "error",
-      );
+      setError(err.message || (hasUpdate ? `Could not update ${label}` : "Could not check updates"));
+      showToast(hasUpdate ? `Could not update ${label}` : "Could not check updates", "error");
+    }
+    setChecking(false);
+  };
+
+  return html`
+    <div class="flex items-center justify-between gap-3">
+      <div class="min-w-0">
+        <p class="text-sm text-gray-300 truncate">
+          <span class="text-gray-500">${label}</span>${" "}v${version || "unknown"}
+        </p>
+        ${error && html`<p class="text-xs text-yellow-500 mt-1">${error}</p>`}
+      </div>
+      <div class="flex items-center gap-2 shrink-0">
+        ${hasUpdate && latestVersion && tagsUrl && html`
+          <a href=${tagsUrl} target="_blank"
+            class="text-xs text-yellow-500 hover:text-yellow-300 transition-colors"
+          >${latestVersion} available</a>
+        `}
+        <button
+          onclick=${handleAction}
+          disabled=${checking}
+          class="text-xs px-2.5 py-1 rounded-lg border border-border text-gray-500 hover:text-gray-300 hover:border-gray-500 transition-colors ${checking ? "opacity-50 cursor-not-allowed" : ""}"
+        >
+          ${checking
+            ? hasUpdate ? "Updating..." : "Checking..."
+            : hasUpdate ? "Update" : "Check updates"}
+        </button>
+      </div>
+    </div>
+  `;
+}
+
+export function Gateway({ status, openclawVersion }) {
+  const [restarting, setRestarting] = useState(false);
+  const isRunning = status === "running" && !restarting;
+  const dotClass = isRunning
+    ? "w-2 h-2 rounded-full bg-green-500"
+    : "w-2 h-2 rounded-full bg-yellow-500 animate-pulse";
+
+  const handleRestart = async () => {
+    if (restarting) return;
+    setRestarting(true);
+    try {
+      await restartGateway();
+      showToast("Gateway restarted", "success");
+    } catch (err) {
+      showToast("Restart failed: " + err.message, "error");
     }
-    setCheckingUpdate(false);
+    setRestarting(false);
   };
 
   return html` <div class="bg-surface border border-border rounded-xl p-4">
@@ -123,41 +147,21 @@ export function Gateway({ status, openclawVersion }) {
         Restart
       </button>
     </div>
-    <div class="mt-3 pt-3 border-t border-border">
-      <div class="flex items-center justify-between gap-3">
-        <div class="min-w-0">
-          <p class="text-sm text-gray-300 truncate">
-            v${currentVersion || openclawVersion || "unknown"}
-          </p>
-          ${updateError &&
-          html`<p class="text-xs text-yellow-500 mt-1">${updateError}</p>`}
-        </div>
-        <div class="flex items-center gap-2 shrink-0">
-          ${hasUpdate &&
-          latestVersion &&
-          html`<a
-            href="https://github.com/openclaw/openclaw/tags"
-            target="_blank"
-            class="text-xs text-yellow-500 hover:text-yellow-300 transition-colors"
-            >${latestVersion} available</a
-          >`}
-          <button
-            onclick=${handleUpdate}
-            disabled=${checkingUpdate}
-            class="text-xs px-2.5 py-1 rounded-lg border border-border text-gray-500 hover:text-gray-300 hover:border-gray-500 transition-colors ${checkingUpdate
-              ? "opacity-50 cursor-not-allowed"
-              : ""}"
-          >
-            ${checkingUpdate
-              ? hasUpdate
-                ? "Updating..."
-                : "Checking..."
-              : hasUpdate
-                ? "Update"
-                : "Check updates"}
-          </button>
-        </div>
-      </div>
+    <div class="mt-3 pt-3 border-t border-border space-y-3">
+      <${VersionRow}
+        label="OpenClaw"
+        currentVersion=${openclawVersion}
+        fetchVersion=${fetchOpenclawVersion}
+        applyUpdate=${updateOpenclaw}
+        tagsUrl="https://github.com/openclaw/openclaw/tags"
+      />
+      <${VersionRow}
+        label="AlphaClaw"
+        currentVersion=${null}
+        fetchVersion=${fetchAlphaclawVersion}
+        applyUpdate=${updateAlphaclaw}
+        tagsUrl="https://www.npmjs.com/package/@chrysb/alphaclaw"
+      />
     </div>
   </div>`;
 }

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

@@ -80,6 +80,17 @@ export async function updateOpenclaw() {
   return res.json();
 }
 
+export async function fetchAlphaclawVersion(refresh = false) {
+  const query = refresh ? '?refresh=1' : '';
+  const res = await authFetch(`/api/alphaclaw/version${query}`);
+  return res.json();
+}
+
+export async function updateAlphaclaw() {
+  const res = await authFetch('/api/alphaclaw/update', { method: 'POST' });
+  return res.json();
+}
+
 export async function fetchSyncCron() {
   const res = await authFetch('/api/sync-cron');
   const text = await res.text();

package/lib/server/alphaclaw-version.js

@@ -0,0 +1,190 @@
+const { exec } = require("child_process");
+const { spawn } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const http = require("http");
+const {
+  kLatestVersionCacheTtlMs,
+  kAlphaclawRegistryUrl,
+  kPackageRoot,
+} = require("./constants");
+
+// kPackageRoot is lib/ — the actual npm package root (with package.json) is one level up
+const kNpmPackageRoot = path.resolve(kPackageRoot, "..");
+
+const createAlphaclawVersionService = () => {
+  let kUpdateStatusCache = { latestVersion: null, hasUpdate: false, fetchedAt: 0 };
+  let kUpdateInProgress = false;
+
+  const readAlphaclawVersion = () => {
+    try {
+      const pkg = JSON.parse(
+        fs.readFileSync(path.join(kNpmPackageRoot, "package.json"), "utf8"),
+      );
+      return pkg.version || null;
+    } catch {
+      return null;
+    }
+  };
+
+  const fetchLatestVersionFromRegistry = () =>
+    new Promise((resolve, reject) => {
+      const get = kAlphaclawRegistryUrl.startsWith("https") ? https.get : http.get;
+      get(kAlphaclawRegistryUrl, { headers: { Accept: "application/json" } }, (res) => {
+        let data = "";
+        res.on("data", (chunk) => { data += chunk; });
+        res.on("end", () => {
+          try {
+            const parsed = JSON.parse(data);
+            resolve(parsed["dist-tags"]?.latest || null);
+          } catch (e) {
+            reject(new Error("Failed to parse registry response"));
+          }
+        });
+      }).on("error", reject);
+    });
+
+  const readAlphaclawUpdateStatus = async ({ refresh = false } = {}) => {
+    const now = Date.now();
+    if (
+      !refresh &&
+      kUpdateStatusCache.fetchedAt &&
+      now - kUpdateStatusCache.fetchedAt < kLatestVersionCacheTtlMs
+    ) {
+      return {
+        latestVersion: kUpdateStatusCache.latestVersion,
+        hasUpdate: kUpdateStatusCache.hasUpdate,
+      };
+    }
+    const currentVersion = readAlphaclawVersion();
+    const latestVersion = await fetchLatestVersionFromRegistry();
+    const hasUpdate = !!(currentVersion && latestVersion && latestVersion !== currentVersion);
+    kUpdateStatusCache = { latestVersion, hasUpdate, fetchedAt: Date.now() };
+    console.log(
+      `[alphaclaw] alphaclaw update status: hasUpdate=${hasUpdate} current=${currentVersion} latest=${latestVersion || "unknown"}`,
+    );
+    return { latestVersion, hasUpdate };
+  };
+
+  const findInstallDir = () => {
+    // Walk up from kNpmPackageRoot to find the consuming project's directory
+    // (the one with node_modules/@chrysb/alphaclaw). In Docker this is /app.
+    let dir = kNpmPackageRoot;
+    while (dir !== path.dirname(dir)) {
+      const parent = path.dirname(dir);
+      if (path.basename(parent) === "node_modules" || parent.includes("node_modules")) {
+        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"]) {
+            return parent;
+          }
+        } catch {}
+      }
+      dir = parent;
+    }
+    // Fallback: if running directly (not from node_modules), use kNpmPackageRoot
+    return kNpmPackageRoot;
+  };
+
+  const installLatestAlphaclaw = () =>
+    new Promise((resolve, reject) => {
+      const installDir = findInstallDir();
+      console.log(`[alphaclaw] Running: npm install @chrysb/alphaclaw@latest (cwd: ${installDir})`);
+      exec(
+        "npm install @chrysb/alphaclaw@latest --omit=dev --no-save --package-lock=false",
+        {
+          cwd: installDir,
+          env: {
+            ...process.env,
+            npm_config_update_notifier: "false",
+            npm_config_fund: "false",
+            npm_config_audit: "false",
+          },
+          timeout: 180000,
+        },
+        (err, stdout, stderr) => {
+          if (err) {
+            const message = String(stderr || err.message || "").trim();
+            console.log(`[alphaclaw] alphaclaw install error: ${message.slice(0, 200)}`);
+            return reject(new Error(message || "Failed to install @chrysb/alphaclaw@latest"));
+          }
+          if (stdout?.trim()) {
+            console.log(`[alphaclaw] alphaclaw install stdout: ${stdout.trim().slice(0, 300)}`);
+          }
+          console.log("[alphaclaw] alphaclaw install completed");
+          resolve({ stdout: stdout?.trim(), stderr: stderr?.trim() });
+        },
+      );
+    });
+
+  const restartProcess = () => {
+    console.log("[alphaclaw] Restarting process...");
+    const child = spawn(process.argv[0], process.argv.slice(1), {
+      detached: true,
+      stdio: "inherit",
+    });
+    child.unref();
+    process.exit(0);
+  };
+
+  const getVersionStatus = async (refresh) => {
+    const currentVersion = readAlphaclawVersion();
+    try {
+      const { latestVersion, hasUpdate } = await readAlphaclawUpdateStatus({ refresh });
+      return { ok: true, currentVersion, latestVersion, hasUpdate };
+    } catch (err) {
+      return {
+        ok: false,
+        currentVersion,
+        latestVersion: kUpdateStatusCache.latestVersion,
+        hasUpdate: kUpdateStatusCache.hasUpdate,
+        error: err.message || "Failed to fetch latest AlphaClaw version",
+      };
+    }
+  };
+
+  const updateAlphaclaw = async () => {
+    if (kUpdateInProgress) {
+      return {
+        status: 409,
+        body: { ok: false, error: "AlphaClaw update already in progress" },
+      };
+    }
+
+    kUpdateInProgress = true;
+    const previousVersion = readAlphaclawVersion();
+    try {
+      await installLatestAlphaclaw();
+      kUpdateStatusCache = { latestVersion: null, hasUpdate: false, fetchedAt: 0 };
+      return {
+        status: 200,
+        body: {
+          ok: true,
+          previousVersion,
+          restarting: true,
+        },
+      };
+    } catch (err) {
+      kUpdateInProgress = false;
+      return {
+        status: 500,
+        body: { ok: false, error: err.message || "Failed to update AlphaClaw" },
+      };
+    }
+  };
+
+  return {
+    readAlphaclawVersion,
+    getVersionStatus,
+    updateAlphaclaw,
+    restartProcess,
+  };
+};
+
+module.exports = { createAlphaclawVersionService };

package/lib/server/constants.js

@@ -106,6 +106,7 @@ const kFallbackOnboardingModels = [
 const kVersionCacheTtlMs = 60 * 1000;
 const kLatestVersionCacheTtlMs = 10 * 60 * 1000;
 const kOpenclawRegistryUrl = "https://registry.npmjs.org/openclaw";
+const kAlphaclawRegistryUrl = "https://registry.npmjs.org/@chrysb%2falphaclaw";
 const kAppDir = kPackageRoot;
 
 const kSystemVars = new Set([
@@ -265,6 +266,7 @@ module.exports = {
   kVersionCacheTtlMs,
   kLatestVersionCacheTtlMs,
   kOpenclawRegistryUrl,
+  kAlphaclawRegistryUrl,
   kAppDir,
   kSystemVars,
   kKnownVars,

package/lib/server/routes/system.js

@@ -12,6 +12,7 @@ const registerSystemRoutes = ({
   isOnboarded,
   getChannelStatus,
   openclawVersionService,
+  alphaclawVersionService,
   clawCmd,
   restartGateway,
   OPENCLAW_DIR,
@@ -183,6 +184,26 @@ const registerSystemRoutes = ({
     res.status(result.status).json(result.body);
   });
 
+  app.get("/api/alphaclaw/version", async (req, res) => {
+    const refresh = String(req.query.refresh || "") === "1";
+    const status = await alphaclawVersionService.getVersionStatus(refresh);
+    res.json(status);
+  });
+
+  app.post("/api/alphaclaw/update", async (req, res) => {
+    console.log("[alphaclaw] /api/alphaclaw/update requested");
+    const result = await alphaclawVersionService.updateAlphaclaw();
+    console.log(
+      `[alphaclaw] /api/alphaclaw/update result: status=${result.status} ok=${result.body?.ok === true}`,
+    );
+    if (result.status === 200 && result.body?.ok) {
+      res.json(result.body);
+      setTimeout(() => alphaclawVersionService.restartProcess(), 1000);
+    } else {
+      res.status(result.status).json(result.body);
+    }
+  });
+
   app.get("/api/gateway-status", async (req, res) => {
     const result = await clawCmd("status");
     res.json(result);

package/lib/server.js

@@ -34,6 +34,7 @@ const { createCommands } = require("./server/commands");
 const { createAuthProfiles } = require("./server/auth-profiles");
 const { createLoginThrottle } = require("./server/login-throttle");
 const { createOpenclawVersionService } = require("./server/openclaw-version");
+const { createAlphaclawVersionService } = require("./server/alphaclaw-version");
 const { syncBootstrapPromptFiles } = require("./server/onboarding/workspace");
 
 const { registerAuthRoutes } = require("./server/routes/auth");
@@ -76,6 +77,7 @@ const openclawVersionService = createOpenclawVersionService({
   restartGateway,
   isOnboarded,
 });
+const alphaclawVersionService = createAlphaclawVersionService();
 
 const { requireAuth } = registerAuthRoutes({ app, loginThrottle });
 app.use(express.static(path.join(__dirname, "public")));
@@ -118,6 +120,7 @@ registerSystemRoutes({
   isOnboarded,
   getChannelStatus,
   openclawVersionService,
+  alphaclawVersionService,
   clawCmd,
   restartGateway,
   OPENCLAW_DIR: constants.OPENCLAW_DIR,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "publishConfig": {
     "access": "public"
   },