@chrysb/alphaclaw 0.3.5-beta.0 → 0.3.5-beta.1

package/lib/public/js/components/sidebar-git-panel.js

@@ -10,6 +10,7 @@ import { showToast } from "./toast.js";
 const html = htm.bind(h);
 const kRefreshMs = 10000;
 const kSyncCommitFileNameLimit = 4;
+const kCommitHistoryLimit = 12;
 
 const formatCommitTime = (unixSeconds) => {
   if (!unixSeconds) return "";
@@ -55,11 +56,58 @@ const getChangedFilePresentation = (changedFile) => {
 };
 
 const formatDelta = (value, prefix) => {
+  if (value === null || value === undefined || value === "") return "";
   const numericValue = Number(value);
-  if (!Number.isFinite(numericValue) || numericValue < 0) return "";
+  if (!Number.isFinite(numericValue) || numericValue <= 0) return "";
   return `${prefix}${numericValue}`;
 };
 
+const getRemoteSyncPresentation = (summary) => {
+  const safeState = String(summary?.syncState || "").trim();
+  const aheadCount = Number(summary?.aheadCount) || 0;
+  const behindCount = Number(summary?.behindCount) || 0;
+  if (safeState === "ahead") {
+    return {
+      label: "↑",
+      title: `Ahead by ${aheadCount}`,
+      className: "is-ahead",
+    };
+  }
+  if (safeState === "behind") {
+    return {
+      label: "↓",
+      title: `Behind by ${behindCount}`,
+      className: "is-behind",
+    };
+  }
+  if (safeState === "diverged") {
+    return {
+      label: "↕",
+      title: `Diverged (${aheadCount} ahead, ${behindCount} behind)`,
+      className: "is-diverged",
+    };
+  }
+  if (safeState === "upstream-gone") {
+    return {
+      label: "!",
+      title: "Upstream missing",
+      className: "is-upstream-gone",
+    };
+  }
+  if (safeState === "no-upstream" || !summary?.hasUpstream) {
+    return {
+      label: "!",
+      title: "Not linked",
+      className: "is-no-upstream",
+    };
+  }
+  return {
+    label: "",
+    title: "Up to date",
+    className: "is-up-to-date",
+  };
+};
+
 const buildSyncCommitMessage = (changedFiles) => {
   const filePaths = Array.isArray(changedFiles)
     ? changedFiles
@@ -138,16 +186,19 @@ export const SidebarGitPanel = ({ onSelectFile = () => {} }) => {
     `;
   }
 
-  const hasUnsyncedChanges = (summary.changedFiles || []).length > 0;
+  const hasUncommittedChanges = (summary.changedFiles || []).length > 0;
+  const aheadCount = Number(summary?.aheadCount) || 0;
+  const canSyncChanges = hasUncommittedChanges || aheadCount > 0;
+  const remoteSync = getRemoteSyncPresentation(summary);
   const handleSyncChanges = async () => {
-    if (!hasUnsyncedChanges || syncing) return;
+    if (!canSyncChanges || syncing) return;
     try {
       setSyncing(true);
       const commitMessage = buildSyncCommitMessage(summary?.changedFiles || []);
       const syncResult = await syncBrowseChanges(commitMessage);
-      if (syncResult?.committed) {
+      if (syncResult?.committed || syncResult?.pushed) {
         window.dispatchEvent(new CustomEvent("alphaclaw:browse-git-synced"));
-        showToast(syncResult.message || "Changes committed", "success");
+        showToast(syncResult.message || "Changes synced", "success");
       } else {
         showToast(syncResult?.message || "No changes to sync", "info");
       }
@@ -189,14 +240,24 @@ export const SidebarGitPanel = ({ onSelectFile = () => {} }) => {
           <${GitBranchLineIcon} className="sidebar-git-bar-icon" />
           <span class="sidebar-git-branch">${summary.branch || "unknown"}</span>
         </span>
-        <span class=${`sidebar-git-dirty ${summary.isDirty ? "is-dirty" : "is-clean"}`}>
-          ${summary.isDirty ? "dirty" : "clean"}
-        </span>
+        ${remoteSync.label
+          ? html`
+              <span
+                class=${`sidebar-git-sync-status ${remoteSync.className}`.trim()}
+                title=${remoteSync.title || ""}
+                aria-label=${remoteSync.title || ""}
+              >
+                ${remoteSync.label}
+              </span>
+            `
+          : null}
       </div>
       <div class="sidebar-git-scroll">
         ${(summary.changedFiles || []).length > 0
           ? html`
-              <div class="sidebar-git-changes-label">unsynced changes</div>
+              <div class="sidebar-git-changes-label">
+                ${`Unsynced Changes (${summary.changedFilesCount || (summary.changedFiles || []).length})`}
+              </div>
               <ul class="sidebar-git-changes-list">
                 ${(summary.changedFiles || []).map((changedFile) => {
                   const presentation = getChangedFilePresentation(changedFile);
@@ -229,7 +290,7 @@ export const SidebarGitPanel = ({ onSelectFile = () => {} }) => {
               <div class="sidebar-git-actions">
                 <${ActionButton}
                   onClick=${handleSyncChanges}
-                  disabled=${!hasUnsyncedChanges}
+                  disabled=${!canSyncChanges}
                   loading=${syncing}
                   loadingMode="inline"
                   idleLabel="Sync Changes"
@@ -245,7 +306,7 @@ export const SidebarGitPanel = ({ onSelectFile = () => {} }) => {
           ? html`
               <div class="sidebar-git-changes-label">commit history</div>
               <ul class="sidebar-git-list">
-                ${(summary.commits || []).slice(0, 4).map(
+                ${(summary.commits || []).slice(0, kCommitHistoryLimit).map(
                   (commit) => html`
                     <li title=${formatCommitTime(commit.timestamp)}>
                       ${commit.url

package/lib/public/js/components/usage-tab.js

@@ -122,7 +122,10 @@ const kUsageMetricUiSettingKey = "usageMetric";
 const SummaryCard = ({ title, tokens, cost }) => html`
   <div class="bg-surface border border-border rounded-xl p-4">
     <h3 class="card-label text-xs">${title}</h3>
-    <div class="text-lg font-semibold mt-1">${formatTokens(tokens)} tokens</div>
+    <div class="text-lg font-semibold mt-1">
+      ${formatTokens(tokens)}
+      <span class="text-xs text-[var(--text-muted)] ml-1">tokens</span>
+    </div>
     <div class="text-xs text-[var(--text-muted)] mt-1">${formatUsd(cost)}</div>
   </div>
 `;

package/lib/public/js/components/watchdog-tab.js

@@ -137,6 +137,9 @@ export const WatchdogTab = ({
   restartingGateway = false,
   onRestartGateway,
   restartSignal = 0,
+  openclawUpdateInProgress = false,
+  onOpenclawVersionActionComplete = () => {},
+  onOpenclawUpdate,
 }) => {
   const eventsPoll = usePolling(() => fetchWatchdogEvents(20), 15000);
   const resourcesPoll = usePolling(() => fetchWatchdogResources(), 5000);
@@ -300,6 +303,9 @@ export const WatchdogTab = ({
         watchdogStatus=${currentWatchdogStatus}
         onRepair=${onRepair}
         repairing=${isRepairInProgress}
+        openclawUpdateInProgress=${openclawUpdateInProgress}
+        onOpenclawVersionActionComplete=${onOpenclawVersionActionComplete}
+        onOpenclawUpdate=${onOpenclawUpdate}
       />
 
       ${(() => {

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

@@ -400,6 +400,22 @@ export const fetchBrowseFileDiff = async (filePath) => {
   return parseJsonOrThrow(res, 'Could not load file diff');
 };
 
+export const fetchBrowseSqliteTable = async ({
+  filePath,
+  table,
+  limit = 50,
+  offset = 0,
+}) => {
+  const params = new URLSearchParams({
+    path: String(filePath || ""),
+    table: String(table || ""),
+    limit: String(limit),
+    offset: String(offset),
+  });
+  const res = await authFetch(`/api/browse/sqlite-table?${params.toString()}`);
+  return parseJsonOrThrow(res, "Could not load sqlite table data");
+};
+
 export const syncBrowseChanges = async (message = "") => {
   const res = await authFetch('/api/browse/git-sync', {
     method: 'POST',

package/lib/public/js/lib/browse-file-policies.js

@@ -0,0 +1,34 @@
+export const kProtectedBrowsePaths = new Set([
+  "openclaw.json",
+  "devices/paired.json",
+]);
+
+export const kLockedBrowsePaths = new Set([
+  "hooks/bootstrap/agents.md",
+  "hooks/bootstrap/tools.md",
+  "skills/control-ui/skill.md",
+  ".alphaclaw/hourly-git-sync.sh",
+  ".alphaclaw/.cli-device-auto-approved",
+]);
+
+export const normalizeBrowsePolicyPath = (inputPath) =>
+  String(inputPath || "")
+    .replaceAll("\\", "/")
+    .replace(/^\.\/+/, "")
+    .replace(/^\/+/, "")
+    .trim()
+    .toLowerCase();
+
+export const matchesBrowsePolicyPath = (policyPathSet, normalizedPath) => {
+  const safeNormalizedPath = String(normalizedPath || "").trim();
+  if (!safeNormalizedPath) return false;
+  for (const policyPath of policyPathSet) {
+    if (
+      safeNormalizedPath === policyPath ||
+      safeNormalizedPath.endsWith(`/${policyPath}`)
+    ) {
+      return true;
+    }
+  }
+  return false;
+};

package/lib/scripts/git

@@ -0,0 +1,40 @@
+#!/bin/bash
+# Git auth shim -- injects GITHUB_TOKEN credentials for network operations
+# inside the configured OpenClaw repo so the agent can use plain git commands.
+
+REAL_GIT="@@REAL_GIT@@"
+OPENCLAW_REPO_ROOT="@@OPENCLAW_REPO_ROOT@@"
+ASKPASS_PATH="/tmp/alphaclaw-git-askpass.sh"
+
+SUBCMD=""
+for arg in "$@"; do
+  case "$arg" in
+    -*) ;;
+    *) SUBCMD="$arg"; break ;;
+  esac
+done
+
+needs_auth() {
+  case "$SUBCMD" in
+    push|pull|fetch|clone|ls-remote) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+in_openclaw_root() {
+  if [ -z "$OPENCLAW_REPO_ROOT" ]; then
+    return 1
+  fi
+  case "$(pwd)" in
+    "$OPENCLAW_REPO_ROOT"|"${OPENCLAW_REPO_ROOT}"/*) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+if [ "${ALPHACLAW_GIT_NO_AUTH:-}" = "1" ] || [ -z "${GITHUB_TOKEN:-}" ] || ! needs_auth || ! in_openclaw_root; then
+  exec "$REAL_GIT" "$@"
+fi
+
+export GIT_TERMINAL_PROMPT=0
+export GIT_ASKPASS="$ASKPASS_PATH"
+exec "$REAL_GIT" "$@"

package/lib/scripts/git-askpass

@@ -0,0 +1,6 @@
+#!/usr/bin/env sh
+case "$1" in
+  *Username*) echo "x-access-token" ;;
+  *Password*) echo "${GITHUB_TOKEN:-}" ;;
+  *) echo "" ;;
+esac

package/lib/server/constants.js

@@ -274,6 +274,13 @@ const kChannelDefs = {
   telegram: { envKey: "TELEGRAM_BOT_TOKEN" },
   discord: { envKey: "DISCORD_BOT_TOKEN" },
 };
+const kLockedBrowsePaths = new Set([
+  "hooks/bootstrap/agents.md",
+  "hooks/bootstrap/tools.md",
+  "skills/control-ui/skill.md",
+  ".alphaclaw/hourly-git-sync.sh",
+  ".alphaclaw/.cli-device-auto-approved",
+]);
 
 const SETUP_API_PREFIXES = [
   "/api/status",
@@ -343,6 +350,7 @@ module.exports = {
   kSystemVars,
   kKnownVars,
   kKnownKeys,
+  kLockedBrowsePaths,
   SCOPE_MAP,
   REVERSE_SCOPE_MAP,
   BASE_SCOPES,

package/lib/server/routes/browse/constants.js

@@ -0,0 +1,51 @@
+const kDefaultTreeDepth = 10;
+const kIgnoredDirectoryNames = new Set([
+  ".git",
+  ".alphaclaw",
+  "node_modules",
+  ".cache",
+  "dist",
+  "build",
+]);
+const kImageMimeTypeByExtension = new Map([
+  [".png", "image/png"],
+  [".jpg", "image/jpeg"],
+  [".jpeg", "image/jpeg"],
+  [".gif", "image/gif"],
+  [".webp", "image/webp"],
+  [".svg", "image/svg+xml"],
+  [".bmp", "image/bmp"],
+  [".ico", "image/x-icon"],
+  [".avif", "image/avif"],
+]);
+const kCommitHistoryLimit = 12;
+const kAudioMimeTypeByExtension = new Map([
+  [".mp3", "audio/mpeg"],
+  [".wav", "audio/wav"],
+  [".ogg", "audio/ogg"],
+  [".oga", "audio/ogg"],
+  [".m4a", "audio/mp4"],
+  [".aac", "audio/aac"],
+  [".flac", "audio/flac"],
+  [".opus", "audio/opus"],
+  [".weba", "audio/webm"],
+]);
+const kSqliteFileExtensions = new Set([
+  ".sqlite",
+  ".sqlite3",
+  ".db",
+  ".db3",
+  ".sdb",
+  ".sqlitedb",
+]);
+const kSqliteTablePageSize = 50;
+
+module.exports = {
+  kDefaultTreeDepth,
+  kIgnoredDirectoryNames,
+  kImageMimeTypeByExtension,
+  kCommitHistoryLimit,
+  kAudioMimeTypeByExtension,
+  kSqliteFileExtensions,
+  kSqliteTablePageSize,
+};

package/lib/server/routes/browse/file-helpers.js

@@ -0,0 +1,43 @@
+const path = require("path");
+const {
+  kImageMimeTypeByExtension,
+  kAudioMimeTypeByExtension,
+  kSqliteFileExtensions,
+} = require("./constants");
+
+const isLikelyBinaryFile = (fs, targetPath) => {
+  let fileHandle = null;
+  try {
+    fileHandle = fs.openSync(targetPath, "r");
+    const sample = Buffer.alloc(512);
+    const bytesRead = fs.readSync(fileHandle, sample, 0, sample.length, 0);
+    for (let index = 0; index < bytesRead; index += 1) {
+      if (sample[index] === 0) return true;
+    }
+    return false;
+  } finally {
+    if (fileHandle !== null) fs.closeSync(fileHandle);
+  }
+};
+
+const getImageMimeType = (targetPath) => {
+  const extension = String(path.extname(targetPath || "") || "").toLowerCase();
+  return kImageMimeTypeByExtension.get(extension) || "";
+};
+
+const getAudioMimeType = (targetPath) => {
+  const extension = String(path.extname(targetPath || "") || "").toLowerCase();
+  return kAudioMimeTypeByExtension.get(extension) || "";
+};
+
+const isSqliteFilePath = (targetPath) => {
+  const extension = String(path.extname(targetPath || "") || "").toLowerCase();
+  return kSqliteFileExtensions.has(extension);
+};
+
+module.exports = {
+  isLikelyBinaryFile,
+  getImageMimeType,
+  getAudioMimeType,
+  isSqliteFilePath,
+};

package/lib/server/routes/browse/git.js

@@ -0,0 +1,131 @@
+const { execFile } = require("child_process");
+
+const runGitCommand = (args, kRootResolved) =>
+  new Promise((resolve) => {
+    execFile(
+      "git",
+      args,
+      { timeout: 10000, cwd: kRootResolved },
+      (error, stdout, stderr) => {
+        if (error) {
+          return resolve({
+            ok: false,
+            error: String(
+              stderr || stdout || error.message || "git command failed",
+            ).trim(),
+          });
+        }
+        return resolve({ ok: true, stdout: String(stdout || "") });
+      },
+    );
+  });
+
+const runGitCommandWithExitCode = (args, kRootResolved) =>
+  new Promise((resolve) => {
+    execFile(
+      "git",
+      args,
+      { timeout: 10000, cwd: kRootResolved },
+      (error, stdout, stderr) => {
+        const safeStdout = String(stdout || "");
+        const safeStderr = String(stderr || "");
+        if (!error) {
+          return resolve({
+            ok: true,
+            stdout: safeStdout,
+            stderr: safeStderr,
+            exitCode: 0,
+          });
+        }
+        return resolve({
+          ok: false,
+          stdout: safeStdout,
+          stderr: safeStderr,
+          exitCode: Number.isInteger(error.code) ? error.code : 1,
+          error: String(error.message || "git command failed"),
+        });
+      },
+    );
+  });
+
+const parseGithubRepoSlug = (value) => {
+  const raw = String(value || "").trim();
+  if (!raw) return "";
+  return raw
+    .replace(/^git@github\.com:/i, "")
+    .replace(/^https:\/\/github\.com\//i, "")
+    .replace(/\.git$/i, "")
+    .trim();
+};
+
+const normalizeChangedPath = (rawPath) => {
+  const value = String(rawPath || "").trim();
+  if (!value) return "";
+  if (value.includes(" -> ")) {
+    const segments = value.split(" -> ");
+    return String(segments[segments.length - 1] || "").trim();
+  }
+  return value;
+};
+
+const parseBranchTracking = (branchLine) => {
+  const safeBranchLine = String(branchLine || "").trim();
+  const withoutPrefix = safeBranchLine.replace(/^##\s*/, "");
+  const [localBranchRaw = "", trackingRaw = ""] = withoutPrefix.split("...");
+  const localBranch = localBranchRaw || "unknown";
+  const trackingSegment = String(trackingRaw || "").trim();
+  const upstreamBranch = trackingSegment.split(" [")[0]?.trim() || "";
+  const hasUpstream = upstreamBranch.length > 0;
+  const countsMatch = trackingSegment.match(/\[([^\]]+)\]/);
+  const countsRaw = countsMatch?.[1] || "";
+  const countParts = countsRaw
+    .split(",")
+    .map((part) => String(part || "").trim())
+    .filter(Boolean);
+  let aheadCount = 0;
+  let behindCount = 0;
+  let upstreamGone = false;
+  countParts.forEach((part) => {
+    const aheadMatch = part.match(/^ahead\s+(\d+)$/i);
+    if (aheadMatch?.[1]) {
+      aheadCount = Number.parseInt(aheadMatch[1], 10) || 0;
+      return;
+    }
+    const behindMatch = part.match(/^behind\s+(\d+)$/i);
+    if (behindMatch?.[1]) {
+      behindCount = Number.parseInt(behindMatch[1], 10) || 0;
+      return;
+    }
+    if (part.toLowerCase() === "gone") {
+      upstreamGone = true;
+    }
+  });
+  const syncState = !hasUpstream
+    ? "no-upstream"
+    : upstreamGone
+      ? "upstream-gone"
+      : aheadCount > 0 && behindCount > 0
+        ? "diverged"
+        : aheadCount > 0
+          ? "ahead"
+          : behindCount > 0
+            ? "behind"
+            : "up-to-date";
+  return {
+    branch: localBranch,
+    upstreamBranch,
+    hasUpstream,
+    upstreamGone,
+    aheadCount,
+    behindCount,
+    syncState,
+  };
+};
+
+module.exports = {
+  runGitCommand,
+  runGitCommandWithExitCode,
+  parseGithubRepoSlug,
+  normalizeChangedPath,
+  parseBranchTracking,
+};