@chrysb/alphaclaw 0.9.13 → 0.9.15

package/README.md

@@ -76,13 +76,14 @@ Or with Docker:
 
 ```dockerfile
 FROM node:22-slim
-RUN apt-get update && apt-get install -y git curl procps cron && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y git curl procps cron tini && rm -rf /var/lib/apt/lists/*
 WORKDIR /app
 COPY package.json ./
 RUN npm install --omit=dev
 ENV PATH="/app/node_modules/.bin:$PATH"
 ENV ALPHACLAW_ROOT_DIR=/data
 EXPOSE 3000
+ENTRYPOINT ["/usr/bin/tini", "--"]
 CMD ["alphaclaw", "start"]
 ```
 

package/bin/alphaclaw.js

@@ -11,6 +11,10 @@ const {
   resolveRealGitPath,
   shouldRefreshHourlyGitSyncScript,
 } = require("../lib/cli/git-runtime");
+const {
+  ensureMainUpstream,
+  restoreMissingOpenclawConfigFromRemote,
+} = require("../lib/cli/openclaw-config-restore");
 const { buildSecretReplacements } = require("../lib/server/helpers");
 const {
   migrateManagedInternalFiles,
@@ -666,146 +670,60 @@ try {
 // ---------------------------------------------------------------------------
 
 const configPath = path.join(openclawDir, "openclaw.json");
-
-if (fs.existsSync(configPath)) {
-  console.log("[alphaclaw] Config exists, reconciling channels...");
-
-  const githubRepo = process.env.GITHUB_WORKSPACE_REPO;
-  if (fs.existsSync(path.join(openclawDir, ".git"))) {
-    if (githubRepo) {
-      const repoUrl = githubRepo
-        .replace(/^git@github\.com:/, "")
-        .replace(/^https:\/\/github\.com\//, "")
-        .replace(/\.git$/, "");
-      const remoteUrl = `https://github.com/${repoUrl}.git`;
-      try {
-        execSync(`git remote set-url origin "${remoteUrl}"`, {
-          cwd: openclawDir,
-          stdio: "ignore",
-        });
-        console.log("[alphaclaw] Repo ready");
-      } catch {}
-    }
-
-    // Migration path: scrub persisted PATs from existing GitHub origin URLs.
+const githubRepo = process.env.GITHUB_WORKSPACE_REPO;
+
+if (fs.existsSync(path.join(openclawDir, ".git"))) {
+  if (githubRepo) {
+    const repoUrl = githubRepo
+      .replace(/^git@github\.com:/, "")
+      .replace(/^https:\/\/github\.com\//, "")
+      .replace(/\.git$/, "");
+    const remoteUrl = `https://github.com/${repoUrl}.git`;
     try {
-      const existingOrigin = execSync("git remote get-url origin", {
+      execSync(`git remote set-url origin "${remoteUrl}"`, {
         cwd: openclawDir,
-        stdio: ["ignore", "pipe", "ignore"],
-        encoding: "utf8",
-      }).trim();
-      const match = existingOrigin.match(
-        /^https:\/\/[^/@]+@github\.com\/(.+)$/i,
-      );
-      if (match?.[1]) {
-        const cleanedPath = String(match[1]).replace(/\.git$/i, "");
-        const cleanedOrigin = `https://github.com/${cleanedPath}.git`;
-        execSync(`git remote set-url origin "${cleanedOrigin}"`, {
-          cwd: openclawDir,
-          stdio: "ignore",
-        });
-        console.log("[alphaclaw] Scrubbed tokenized GitHub remote URL");
-      }
+        stdio: "ignore",
+      });
+      console.log("[alphaclaw] Repo ready");
     } catch {}
+  }
 
-    const bootRestoreConfigFromRemote = () => {
-      const branch = (() => {
-        try {
-          return (
-            String(
-              execSync("git symbolic-ref --short HEAD", {
-                cwd: openclawDir,
-                stdio: ["ignore", "pipe", "ignore"],
-                encoding: "utf8",
-              }),
-            ).trim() || "main"
-          );
-        } catch {
-          return "main";
-        }
-      })();
-      const githubToken = String(process.env.GITHUB_TOKEN || "").trim();
-      const gitEnv = { ...process.env };
-      const askPassPath = path.join(
-        os.tmpdir(),
-        `alphaclaw-boot-git-askpass-${process.pid}.sh`,
-      );
-      try {
-        if (githubToken) {
-          fs.writeFileSync(
-            askPassPath,
-            [
-              "#!/usr/bin/env sh",
-              'case "$1" in',
-              '  *Username*) echo "x-access-token" ;;',
-              '  *Password*) echo "${GITHUB_TOKEN:-}" ;;',
-              '  *) echo "" ;;',
-              "esac",
-              "",
-            ].join("\n"),
-            { mode: 0o700 },
-          );
-          gitEnv.GITHUB_TOKEN = githubToken;
-          gitEnv.GIT_TERMINAL_PROMPT = "0";
-          gitEnv.GIT_ASKPASS = askPassPath;
-        }
-        execSync(`git ls-remote --exit-code --heads origin "${branch}"`, {
-          cwd: openclawDir,
-          stdio: "ignore",
-          env: gitEnv,
-        });
-        execSync(`git fetch --quiet origin "${branch}"`, {
-          cwd: openclawDir,
-          stdio: "ignore",
-          env: gitEnv,
-        });
-        try {
-          execSync("git show-ref --verify --quiet refs/heads/main", {
-            cwd: openclawDir,
-            stdio: "ignore",
-          });
-          try {
-            execSync("git rev-parse --abbrev-ref --symbolic-full-name main@{upstream}", {
-              cwd: openclawDir,
-              stdio: "ignore",
-            });
-          } catch {
-            execSync("git branch --set-upstream-to=origin/main main", {
-              cwd: openclawDir,
-              stdio: "ignore",
-              env: gitEnv,
-            });
-            console.log("[alphaclaw] Set main upstream to origin/main");
-          }
-        } catch {}
-        const remoteConfig = String(
-          execSync(`git show "origin/${branch}:openclaw.json"`, {
-            cwd: openclawDir,
-            stdio: ["ignore", "pipe", "ignore"],
-            encoding: "utf8",
-            env: gitEnv,
-          }),
-        );
-        if (remoteConfig.trim()) {
-          fs.writeFileSync(configPath, remoteConfig);
-          console.log(
-            `[alphaclaw] Restored openclaw.json from origin/${branch}`,
-          );
-        }
-      } catch (e) {
-        console.log(
-          `[alphaclaw] Remote config restore skipped: ${String(e.message || "").slice(0, 200)}`,
-        );
-      } finally {
-        if (githubToken) {
-          try {
-            fs.rmSync(askPassPath, { force: true });
-          } catch {}
-        }
-      }
-    };
-    bootRestoreConfigFromRemote();
+  // Migration path: scrub persisted PATs from existing GitHub origin URLs.
+  try {
+    const existingOrigin = execSync("git remote get-url origin", {
+      cwd: openclawDir,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8",
+    }).trim();
+    const match = existingOrigin.match(/^https:\/\/[^/@]+@github\.com\/(.+)$/i);
+    if (match?.[1]) {
+      const cleanedPath = String(match[1]).replace(/\.git$/i, "");
+      const cleanedOrigin = `https://github.com/${cleanedPath}.git`;
+      execSync(`git remote set-url origin "${cleanedOrigin}"`, {
+        cwd: openclawDir,
+        stdio: "ignore",
+      });
+      console.log("[alphaclaw] Scrubbed tokenized GitHub remote URL");
+    }
+  } catch {}
+
+  restoreMissingOpenclawConfigFromRemote({
+    openclawDir,
+    configPath,
+    env: process.env,
+  });
+  if (
+    ensureMainUpstream({
+      openclawDir,
+      gitEnv: process.env,
+    })
+  ) {
+    console.log("[alphaclaw] Set main upstream to origin/main");
   }
+}
+
+if (fs.existsSync(configPath)) {
+  console.log("[alphaclaw] Config exists, reconciling channels...");
 
   try {
     const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));

package/lib/cli/openclaw-config-restore.js

@@ -0,0 +1,162 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const kOpenclawConfigFile = "openclaw.json";
+
+const quoteArg = (value) => `'${String(value || "").replace(/'/g, "'\"'\"'")}'`;
+
+const resolveCurrentBranch = ({ execSyncImpl, openclawDir }) => {
+  try {
+    return (
+      String(
+        execSyncImpl("git symbolic-ref --short HEAD", {
+          cwd: openclawDir,
+          stdio: ["ignore", "pipe", "ignore"],
+          encoding: "utf8",
+        }),
+      ).trim() || "main"
+    );
+  } catch {
+    return "main";
+  }
+};
+
+const createGitEnv = ({ fsModule, osModule, env, processId }) => {
+  const githubToken = String(env.GITHUB_TOKEN || "").trim();
+  const gitEnv = { ...env };
+  if (!githubToken) {
+    return { gitEnv, askPassPath: "" };
+  }
+
+  const askPassPath = path.join(
+    osModule.tmpdir(),
+    `alphaclaw-boot-git-askpass-${processId}.sh`,
+  );
+  fsModule.writeFileSync(
+    askPassPath,
+    [
+      "#!/usr/bin/env sh",
+      'case "$1" in',
+      '  *Username*) echo "x-access-token" ;;',
+      '  *Password*) echo "${GITHUB_TOKEN:-}" ;;',
+      '  *) echo "" ;;',
+      "esac",
+      "",
+    ].join("\n"),
+    { mode: 0o700 },
+  );
+  gitEnv.GITHUB_TOKEN = githubToken;
+  gitEnv.GIT_TERMINAL_PROMPT = "0";
+  gitEnv.GIT_ASKPASS = askPassPath;
+  return { gitEnv, askPassPath };
+};
+
+const restoreMissingOpenclawConfigFromRemote = ({
+  fsModule = fs,
+  osModule = os,
+  execSyncImpl = execSync,
+  env = process.env,
+  logger = console,
+  processId = process.pid,
+  openclawDir,
+  configPath = path.join(openclawDir || "", kOpenclawConfigFile),
+} = {}) => {
+  if (!openclawDir) {
+    throw new Error("openclawDir is required");
+  }
+
+  if (fsModule.existsSync(configPath)) {
+    logger.log(
+      "[alphaclaw] Remote config restore skipped: local openclaw.json already exists",
+    );
+    return { restored: false, skipped: true, reason: "exists" };
+  }
+
+  const branch = resolveCurrentBranch({ execSyncImpl, openclawDir });
+  const { gitEnv, askPassPath } = createGitEnv({
+    fsModule,
+    osModule,
+    env,
+    processId,
+  });
+
+  try {
+    execSyncImpl(
+      `git ls-remote --exit-code --heads origin ${quoteArg(branch)}`,
+      {
+        cwd: openclawDir,
+        stdio: "ignore",
+        env: gitEnv,
+      },
+    );
+    execSyncImpl(`git fetch --quiet origin ${quoteArg(branch)}`, {
+      cwd: openclawDir,
+      stdio: "ignore",
+      env: gitEnv,
+    });
+    const remoteConfig = String(
+      execSyncImpl(`git show ${quoteArg(`origin/${branch}:openclaw.json`)}`, {
+        cwd: openclawDir,
+        stdio: ["ignore", "pipe", "ignore"],
+        encoding: "utf8",
+        env: gitEnv,
+      }),
+    );
+    if (!remoteConfig.trim()) {
+      logger.log("[alphaclaw] Remote config restore skipped: remote config empty");
+      return { restored: false, skipped: true, reason: "empty_remote", branch };
+    }
+    fsModule.writeFileSync(configPath, remoteConfig);
+    logger.log(`[alphaclaw] Restored missing openclaw.json from origin/${branch}`);
+    return { restored: true, skipped: false, reason: "missing", branch };
+  } catch (e) {
+    logger.log(
+      `[alphaclaw] Remote config restore skipped: ${String(e.message || "").slice(0, 200)}`,
+    );
+    return {
+      restored: false,
+      skipped: true,
+      reason: "error",
+      branch,
+      error: e,
+    };
+  } finally {
+    if (askPassPath) {
+      try {
+        fsModule.rmSync(askPassPath, { force: true });
+      } catch {}
+    }
+  }
+};
+
+const ensureMainUpstream = ({ execSyncImpl = execSync, openclawDir, gitEnv }) => {
+  try {
+    execSyncImpl("git show-ref --verify --quiet refs/heads/main", {
+      cwd: openclawDir,
+      stdio: "ignore",
+    });
+    try {
+      execSyncImpl("git rev-parse --abbrev-ref --symbolic-full-name main@{upstream}", {
+        cwd: openclawDir,
+        stdio: "ignore",
+      });
+    } catch {
+      execSyncImpl("git branch --set-upstream-to=origin/main main", {
+        cwd: openclawDir,
+        stdio: "ignore",
+        env: gitEnv,
+      });
+      return true;
+    }
+  } catch {}
+  return false;
+};
+
+module.exports = {
+  ensureMainUpstream,
+  restoreMissingOpenclawConfigFromRemote,
+};

package/lib/public/css/explorer.css

@@ -189,10 +189,12 @@
 
 .sidebar-agent-emoji {
   flex: 0 0 auto;
-  width: 14px;
+  min-width: 14px;
+  max-width: 1.5em;
   line-height: 1;
   font-size: 14px;
   text-align: center;
+  overflow: hidden;
 }
 
 .sidebar-agent-name {