@poolzin/pool-bot 2026.2.11 → 2026.2.18

package/dist/cli/update-cli/progress.js

@@ -0,0 +1,121 @@
+import { spinner } from "@clack/prompts";
+import { formatDurationPrecise } from "../../infra/format-time/format-duration.js";
+import { defaultRuntime } from "../../runtime.js";
+import { theme } from "../../terminal/theme.js";
+const STEP_LABELS = {
+    "clean check": "Working directory is clean",
+    "upstream check": "Upstream branch exists",
+    "git fetch": "Fetching latest changes",
+    "git rebase": "Rebasing onto target commit",
+    "git rev-parse @{upstream}": "Resolving upstream commit",
+    "git rev-list": "Enumerating candidate commits",
+    "git clone": "Cloning git checkout",
+    "preflight worktree": "Preparing preflight worktree",
+    "preflight cleanup": "Cleaning preflight worktree",
+    "deps install": "Installing dependencies",
+    build: "Building",
+    "ui:build": "Building UI assets",
+    "ui:build (post-doctor repair)": "Restoring missing UI assets",
+    "ui assets verify": "Validating UI assets",
+    "openclaw doctor entry": "Checking doctor entrypoint",
+    "openclaw doctor": "Running doctor checks",
+    "git rev-parse HEAD (after)": "Verifying update",
+    "global update": "Updating via package manager",
+    "global install": "Installing global package",
+};
+function getStepLabel(step) {
+    return STEP_LABELS[step.name] ?? step.name;
+}
+export function createUpdateProgress(enabled) {
+    if (!enabled) {
+        return {
+            progress: {},
+            stop: () => { },
+        };
+    }
+    let currentSpinner = null;
+    const progress = {
+        onStepStart: (step) => {
+            currentSpinner = spinner();
+            currentSpinner.start(theme.accent(getStepLabel(step)));
+        },
+        onStepComplete: (step) => {
+            if (!currentSpinner) {
+                return;
+            }
+            const label = getStepLabel(step);
+            const duration = theme.muted(`(${formatDurationPrecise(step.durationMs)})`);
+            const icon = step.exitCode === 0 ? theme.success("\u2713") : theme.error("\u2717");
+            currentSpinner.stop(`${icon} ${label} ${duration}`);
+            currentSpinner = null;
+            if (step.exitCode !== 0 && step.stderrTail) {
+                const lines = step.stderrTail.split("\n").slice(-10);
+                for (const line of lines) {
+                    if (line.trim()) {
+                        defaultRuntime.log(`    ${theme.error(line)}`);
+                    }
+                }
+            }
+        },
+    };
+    return {
+        progress,
+        stop: () => {
+            if (currentSpinner) {
+                currentSpinner.stop();
+                currentSpinner = null;
+            }
+        },
+    };
+}
+function formatStepStatus(exitCode) {
+    if (exitCode === 0) {
+        return theme.success("\u2713");
+    }
+    if (exitCode === null) {
+        return theme.warn("?");
+    }
+    return theme.error("\u2717");
+}
+export function printResult(result, opts) {
+    if (opts.json) {
+        defaultRuntime.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const statusColor = result.status === "ok" ? theme.success : result.status === "skipped" ? theme.warn : theme.error;
+    defaultRuntime.log("");
+    defaultRuntime.log(`${theme.heading("Update Result:")} ${statusColor(result.status.toUpperCase())}`);
+    if (result.root) {
+        defaultRuntime.log(`  Root: ${theme.muted(result.root)}`);
+    }
+    if (result.reason) {
+        defaultRuntime.log(`  Reason: ${theme.muted(result.reason)}`);
+    }
+    if (result.before?.version || result.before?.sha) {
+        const before = result.before.version ?? result.before.sha?.slice(0, 8) ?? "";
+        defaultRuntime.log(`  Before: ${theme.muted(before)}`);
+    }
+    if (result.after?.version || result.after?.sha) {
+        const after = result.after.version ?? result.after.sha?.slice(0, 8) ?? "";
+        defaultRuntime.log(`  After: ${theme.muted(after)}`);
+    }
+    if (!opts.hideSteps && result.steps.length > 0) {
+        defaultRuntime.log("");
+        defaultRuntime.log(theme.heading("Steps:"));
+        for (const step of result.steps) {
+            const status = formatStepStatus(step.exitCode);
+            const duration = theme.muted(`(${formatDurationPrecise(step.durationMs)})`);
+            defaultRuntime.log(`  ${status} ${step.name} ${duration}`);
+            if (step.exitCode !== 0 && step.stderrTail) {
+                const lines = step.stderrTail.split("\n").slice(0, 5);
+                for (const line of lines) {
+                    if (line.trim()) {
+                        defaultRuntime.log(`      ${theme.error(line)}`);
+                    }
+                }
+            }
+        }
+    }
+    defaultRuntime.log("");
+    defaultRuntime.log(`Total time: ${theme.muted(formatDurationPrecise(result.durationMs))}`);
+}

package/dist/cli/update-cli/restart-helper.js

@@ -0,0 +1,108 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { resolveGatewayLaunchAgentLabel, resolveGatewaySystemdServiceName, resolveGatewayWindowsTaskName, } from "../../daemon/constants.js";
+/**
+ * Shell-escape a string for embedding in single-quoted shell arguments.
+ * Replaces every `'` with `'\''` (end quote, escaped quote, resume quote).
+ * For batch scripts, validates against special characters instead.
+ */
+function shellEscape(value) {
+    return value.replace(/'/g, "'\\''");
+}
+/** Validates a string is safe for embedding in a batch (cmd.exe) script. */
+function isBatchSafe(value) {
+    // Reject characters that have special meaning in batch: & | < > ^ % " ` $
+    return /^[A-Za-z0-9 _\-().]+$/.test(value);
+}
+/**
+ * Prepares a standalone script to restart the gateway service.
+ * This script is written to a temporary directory and does not depend on
+ * the installed package files, ensuring restart capability even if the
+ * update process temporarily removes or corrupts installation files.
+ */
+export async function prepareRestartScript(env = process.env) {
+    const tmpDir = os.tmpdir();
+    const timestamp = Date.now();
+    const platform = process.platform;
+    let scriptContent = "";
+    let filename = "";
+    try {
+        if (platform === "linux") {
+            const serviceName = resolveGatewaySystemdServiceName(env.POOLBOT_PROFILE);
+            const escaped = shellEscape(`${serviceName}.service`);
+            filename = `openclaw-restart-${timestamp}.sh`;
+            scriptContent = `#!/bin/sh
+# Standalone restart script — survives parent process termination.
+# Wait briefly to ensure file locks are released after update.
+sleep 1
+systemctl --user restart '${escaped}'
+# Self-cleanup
+rm -f "$0"
+`;
+        }
+        else if (platform === "darwin") {
+            const label = resolveGatewayLaunchAgentLabel(env.POOLBOT_PROFILE);
+            const escaped = shellEscape(label);
+            // Fallback to 501 if getuid is not available (though it should be on macOS)
+            const uid = process.getuid ? process.getuid() : 501;
+            filename = `openclaw-restart-${timestamp}.sh`;
+            scriptContent = `#!/bin/sh
+# Standalone restart script — survives parent process termination.
+# Wait briefly to ensure file locks are released after update.
+sleep 1
+launchctl kickstart -k 'gui/${uid}/${escaped}'
+# Self-cleanup
+rm -f "$0"
+`;
+        }
+        else if (platform === "win32") {
+            const taskName = resolveGatewayWindowsTaskName(env.POOLBOT_PROFILE);
+            if (!isBatchSafe(taskName)) {
+                return null;
+            }
+            filename = `openclaw-restart-${timestamp}.bat`;
+            scriptContent = `@echo off
+REM Standalone restart script — survives parent process termination.
+REM Wait briefly to ensure file locks are released after update.
+timeout /t 2 /nobreak >nul
+schtasks /End /TN "${taskName}"
+schtasks /Run /TN "${taskName}"
+REM Self-cleanup
+del "%~f0"
+`;
+        }
+        else {
+            return null;
+        }
+        const scriptPath = path.join(tmpDir, filename);
+        await fs.writeFile(scriptPath, scriptContent, { mode: 0o755 });
+        return scriptPath;
+    }
+    catch {
+        // If we can't write the script, we'll fall back to the standard restart method
+        return null;
+    }
+}
+/**
+ * Executes the prepared restart script as a **detached** process.
+ *
+ * The script must outlive the CLI process because the CLI itself is part
+ * of the service being restarted — `systemctl restart` / `launchctl
+ * kickstart -k` will terminate the current process tree.  Using
+ * `spawn({ detached: true })` + `unref()` ensures the script survives
+ * the parent's exit.
+ *
+ * Resolves immediately after spawning; the script runs independently.
+ */
+export async function runRestartScript(scriptPath) {
+    const isWindows = process.platform === "win32";
+    const file = isWindows ? "cmd.exe" : "/bin/sh";
+    const args = isWindows ? ["/c", scriptPath] : [scriptPath];
+    const child = spawn(file, args, {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+}

package/dist/cli/update-cli/shared.js

@@ -0,0 +1,196 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { resolveStateDir } from "../../config/paths.js";
+import { resolveOpenClawPackageRoot } from "../../infra/openclaw-root.js";
+import { readPackageName, readPackageVersion } from "../../infra/package-json.js";
+import { trimLogTail } from "../../infra/restart-sentinel.js";
+import { parseSemver } from "../../infra/runtime-guard.js";
+import { fetchNpmTagVersion } from "../../infra/update-check.js";
+import { detectGlobalInstallManagerByPresence, detectGlobalInstallManagerForRoot, } from "../../infra/update-global.js";
+import { runCommandWithTimeout } from "../../process/exec.js";
+import { defaultRuntime } from "../../runtime.js";
+import { theme } from "../../terminal/theme.js";
+import { pathExists } from "../../utils.js";
+const POOLBOT_REPO_URL = "https://github.com/openclaw/openclaw.git";
+const MAX_LOG_CHARS = 8000;
+export const DEFAULT_PACKAGE_NAME = "poolbot";
+const CORE_PACKAGE_NAMES = new Set([DEFAULT_PACKAGE_NAME]);
+export function normalizeTag(value) {
+    if (!value) {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    if (trimmed.startsWith("openclaw@")) {
+        return trimmed.slice("openclaw@".length);
+    }
+    if (trimmed.startsWith(`${DEFAULT_PACKAGE_NAME}@`)) {
+        return trimmed.slice(`${DEFAULT_PACKAGE_NAME}@`.length);
+    }
+    return trimmed;
+}
+export function normalizeVersionTag(tag) {
+    const trimmed = tag.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const cleaned = trimmed.startsWith("v") ? trimmed.slice(1) : trimmed;
+    return parseSemver(cleaned) ? cleaned : null;
+}
+export { readPackageName, readPackageVersion };
+export async function resolveTargetVersion(tag, timeoutMs) {
+    const direct = normalizeVersionTag(tag);
+    if (direct) {
+        return direct;
+    }
+    const res = await fetchNpmTagVersion({ tag, timeoutMs });
+    return res.version ?? null;
+}
+export async function isGitCheckout(root) {
+    try {
+        await fs.stat(path.join(root, ".git"));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isCorePackage(root) {
+    const name = await readPackageName(root);
+    return Boolean(name && CORE_PACKAGE_NAMES.has(name));
+}
+export async function isEmptyDir(targetPath) {
+    try {
+        const entries = await fs.readdir(targetPath);
+        return entries.length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveGitInstallDir() {
+    const override = process.env.POOLBOT_GIT_DIR?.trim();
+    if (override) {
+        return path.resolve(override);
+    }
+    return resolveDefaultGitDir();
+}
+function resolveDefaultGitDir() {
+    return resolveStateDir(process.env, os.homedir);
+}
+export function resolveNodeRunner() {
+    const base = path.basename(process.execPath).toLowerCase();
+    if (base === "node" || base === "node.exe") {
+        return process.execPath;
+    }
+    return "node";
+}
+export async function resolveUpdateRoot() {
+    return ((await resolveOpenClawPackageRoot({
+        moduleUrl: import.meta.url,
+        argv1: process.argv[1],
+        cwd: process.cwd(),
+    })) ?? process.cwd());
+}
+export async function runUpdateStep(params) {
+    const command = params.argv.join(" ");
+    params.progress?.onStepStart?.({
+        name: params.name,
+        command,
+        index: 0,
+        total: 0,
+    });
+    const started = Date.now();
+    const res = await runCommandWithTimeout(params.argv, {
+        cwd: params.cwd,
+        timeoutMs: params.timeoutMs,
+    });
+    const durationMs = Date.now() - started;
+    const stderrTail = trimLogTail(res.stderr, MAX_LOG_CHARS);
+    params.progress?.onStepComplete?.({
+        name: params.name,
+        command,
+        index: 0,
+        total: 0,
+        durationMs,
+        exitCode: res.code,
+        stderrTail,
+    });
+    return {
+        name: params.name,
+        command,
+        cwd: params.cwd ?? process.cwd(),
+        durationMs,
+        exitCode: res.code,
+        stdoutTail: trimLogTail(res.stdout, MAX_LOG_CHARS),
+        stderrTail,
+    };
+}
+export async function ensureGitCheckout(params) {
+    const dirExists = await pathExists(params.dir);
+    if (!dirExists) {
+        return await runUpdateStep({
+            name: "git clone",
+            argv: ["git", "clone", POOLBOT_REPO_URL, params.dir],
+            timeoutMs: params.timeoutMs,
+            progress: params.progress,
+        });
+    }
+    if (!(await isGitCheckout(params.dir))) {
+        const empty = await isEmptyDir(params.dir);
+        if (!empty) {
+            throw new Error(`POOLBOT_GIT_DIR points at a non-git directory: ${params.dir}. Set POOLBOT_GIT_DIR to an empty folder or an openclaw checkout.`);
+        }
+        return await runUpdateStep({
+            name: "git clone",
+            argv: ["git", "clone", POOLBOT_REPO_URL, params.dir],
+            cwd: params.dir,
+            timeoutMs: params.timeoutMs,
+            progress: params.progress,
+        });
+    }
+    if (!(await isCorePackage(params.dir))) {
+        throw new Error(`POOLBOT_GIT_DIR does not look like a core checkout: ${params.dir}.`);
+    }
+    return null;
+}
+export async function resolveGlobalManager(params) {
+    const runCommand = async (argv, options) => {
+        const res = await runCommandWithTimeout(argv, options);
+        return { stdout: res.stdout, stderr: res.stderr, code: res.code };
+    };
+    if (params.installKind === "package") {
+        const detected = await detectGlobalInstallManagerForRoot(runCommand, params.root, params.timeoutMs);
+        if (detected) {
+            return detected;
+        }
+    }
+    const byPresence = await detectGlobalInstallManagerByPresence(runCommand, params.timeoutMs);
+    return byPresence ?? "npm";
+}
+export async function tryWriteCompletionCache(root, jsonMode) {
+    const binPath = path.join(root, "openclaw.mjs");
+    if (!(await pathExists(binPath))) {
+        return;
+    }
+    const result = spawnSync(resolveNodeRunner(), [binPath, "completion", "--write-state"], {
+        cwd: root,
+        env: process.env,
+        encoding: "utf-8",
+    });
+    if (result.error) {
+        if (!jsonMode) {
+            defaultRuntime.log(theme.warn(`Completion cache update failed: ${String(result.error)}`));
+        }
+        return;
+    }
+    if (result.status !== 0 && !jsonMode) {
+        const stderr = (result.stderr ?? "").toString().trim();
+        const detail = stderr ? ` (${stderr})` : "";
+        defaultRuntime.log(theme.warn(`Completion cache update failed${detail}.`));
+    }
+}

package/dist/cli/update-cli/status.js

@@ -0,0 +1,97 @@
+import { formatUpdateAvailableHint, formatUpdateOneLiner, resolveUpdateAvailability, } from "../../commands/status.update.js";
+import { readConfigFileSnapshot } from "../../config/config.js";
+import { normalizeUpdateChannel, resolveUpdateChannelDisplay, } from "../../infra/update-channels.js";
+import { checkUpdateStatus } from "../../infra/update-check.js";
+import { defaultRuntime } from "../../runtime.js";
+import { renderTable } from "../../terminal/table.js";
+import { theme } from "../../terminal/theme.js";
+import { resolveUpdateRoot } from "./shared.js";
+function formatGitStatusLine(params) {
+    const shortSha = params.sha ? params.sha.slice(0, 8) : null;
+    const branch = params.branch && params.branch !== "HEAD" ? params.branch : null;
+    const tag = params.tag;
+    const parts = [
+        branch ?? (tag ? "detached" : "git"),
+        tag ? `tag ${tag}` : null,
+        shortSha ? `@ ${shortSha}` : null,
+    ].filter(Boolean);
+    return parts.join(" · ");
+}
+export async function updateStatusCommand(opts) {
+    const timeoutMs = opts.timeout ? Number.parseInt(opts.timeout, 10) * 1000 : undefined;
+    if (timeoutMs !== undefined && (Number.isNaN(timeoutMs) || timeoutMs <= 0)) {
+        defaultRuntime.error("--timeout must be a positive integer (seconds)");
+        defaultRuntime.exit(1);
+        return;
+    }
+    const root = await resolveUpdateRoot();
+    const configSnapshot = await readConfigFileSnapshot();
+    const configChannel = configSnapshot.valid
+        ? normalizeUpdateChannel(configSnapshot.config.update?.channel)
+        : null;
+    const update = await checkUpdateStatus({
+        root,
+        timeoutMs: timeoutMs ?? 3500,
+        fetchGit: true,
+        includeRegistry: true,
+    });
+    const channelInfo = resolveUpdateChannelDisplay({
+        configChannel,
+        installKind: update.installKind,
+        gitTag: update.git?.tag ?? null,
+        gitBranch: update.git?.branch ?? null,
+    });
+    const channelLabel = channelInfo.label;
+    const gitLabel = update.installKind === "git"
+        ? formatGitStatusLine({
+            branch: update.git?.branch ?? null,
+            tag: update.git?.tag ?? null,
+            sha: update.git?.sha ?? null,
+        })
+        : null;
+    const updateAvailability = resolveUpdateAvailability(update);
+    const updateLine = formatUpdateOneLiner(update).replace(/^Update:\s*/i, "");
+    if (opts.json) {
+        defaultRuntime.log(JSON.stringify({
+            update,
+            channel: {
+                value: channelInfo.channel,
+                source: channelInfo.source,
+                label: channelLabel,
+                config: configChannel,
+            },
+            availability: updateAvailability,
+        }, null, 2));
+        return;
+    }
+    const tableWidth = Math.max(60, (process.stdout.columns ?? 120) - 1);
+    const installLabel = update.installKind === "git"
+        ? `git (${update.root ?? "unknown"})`
+        : update.installKind === "package"
+            ? update.packageManager
+            : "unknown";
+    const rows = [
+        { Item: "Install", Value: installLabel },
+        { Item: "Channel", Value: channelLabel },
+        ...(gitLabel ? [{ Item: "Git", Value: gitLabel }] : []),
+        {
+            Item: "Update",
+            Value: updateAvailability.available ? theme.warn(`available · ${updateLine}`) : updateLine,
+        },
+    ];
+    defaultRuntime.log(theme.heading("OpenClaw update status"));
+    defaultRuntime.log("");
+    defaultRuntime.log(renderTable({
+        width: tableWidth,
+        columns: [
+            { key: "Item", header: "Item", minWidth: 10 },
+            { key: "Value", header: "Value", flex: true, minWidth: 24 },
+        ],
+        rows,
+    }).trimEnd());
+    defaultRuntime.log("");
+    const updateHint = formatUpdateAvailableHint(update);
+    if (updateHint) {
+        defaultRuntime.log(theme.warn(updateHint));
+    }
+}

package/dist/cli/update-cli/suppress-deprecations.js

@@ -0,0 +1,17 @@
+/**
+ * Suppress Node.js deprecation warnings.
+ *
+ * On Node.js v23+ `process.noDeprecation` may be a read-only property
+ * (defined via a getter on the prototype with no setter), so the
+ * assignment can throw. We fall back to the environment variable which
+ * achieves the same effect.
+ */
+export function suppressDeprecations() {
+    try {
+        process.noDeprecation = true;
+    }
+    catch {
+        // read-only on Node v23+; NODE_NO_WARNINGS below covers this case
+    }
+    process.env.NODE_NO_WARNINGS = "1";
+}