@poolzin/pool-bot 2026.2.11 → 2026.2.18

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

@@ -0,0 +1,506 @@
+import path from "node:path";
+import { confirm, isCancel } from "@clack/prompts";
+import { checkShellCompletionStatus, ensureCompletionCacheExists, } from "../../commands/doctor-completion.js";
+import { doctorCommand } from "../../commands/doctor.js";
+import { readConfigFileSnapshot, writeConfigFile } from "../../config/config.js";
+import { resolveGatewayService } from "../../daemon/service.js";
+import { channelToNpmTag, DEFAULT_GIT_CHANNEL, DEFAULT_PACKAGE_CHANNEL, normalizeUpdateChannel, } from "../../infra/update-channels.js";
+import { compareSemverStrings, resolveNpmChannelTag, checkUpdateStatus, } from "../../infra/update-check.js";
+import { cleanupGlobalRenameDirs, globalInstallArgs, resolveGlobalPackageRoot, } from "../../infra/update-global.js";
+import { runGatewayUpdate } from "../../infra/update-runner.js";
+import { syncPluginsForUpdateChannel, updateNpmInstalledPlugins } from "../../plugins/update.js";
+import { runCommandWithTimeout } from "../../process/exec.js";
+import { defaultRuntime } from "../../runtime.js";
+import { stylePromptMessage } from "../../terminal/prompt-style.js";
+import { theme } from "../../terminal/theme.js";
+import { pathExists } from "../../utils.js";
+import { replaceCliName, resolveCliName } from "../cli-name.js";
+import { formatCliCommand } from "../command-format.js";
+import { installCompletion } from "../completion-cli.js";
+import { runDaemonRestart } from "../daemon-cli.js";
+import { createUpdateProgress, printResult } from "./progress.js";
+import { prepareRestartScript, runRestartScript } from "./restart-helper.js";
+import { DEFAULT_PACKAGE_NAME, ensureGitCheckout, normalizeTag, readPackageName, readPackageVersion, resolveGitInstallDir, resolveGlobalManager, resolveNodeRunner, resolveTargetVersion, resolveUpdateRoot, runUpdateStep, tryWriteCompletionCache, } from "./shared.js";
+import { suppressDeprecations } from "./suppress-deprecations.js";
+const CLI_NAME = resolveCliName();
+const UPDATE_QUIPS = [
+    "Leveled up! New skills unlocked. You're welcome.",
+    "Fresh code, same lobster. Miss me?",
+    "Back and better. Did you even notice I was gone?",
+    "Update complete. I learned some new tricks while I was out.",
+    "Upgraded! Now with 23% more sass.",
+    "I've evolved. Try to keep up.",
+    "New version, who dis? Oh right, still me but shinier.",
+    "Patched, polished, and ready to pinch. Let's go.",
+    "The lobster has molted. Harder shell, sharper claws.",
+    "Update done! Check the changelog or just trust me, it's good.",
+    "Reborn from the boiling waters of npm. Stronger now.",
+    "I went away and came back smarter. You should try it sometime.",
+    "Update complete. The bugs feared me, so they left.",
+    "New version installed. Old version sends its regards.",
+    "Firmware fresh. Brain wrinkles: increased.",
+    "I've seen things you wouldn't believe. Anyway, I'm updated.",
+    "Back online. The changelog is long but our friendship is longer.",
+    "Upgraded! Peter fixed stuff. Blame him if it breaks.",
+    "Molting complete. Please don't look at my soft shell phase.",
+    "Version bump! Same chaos energy, fewer crashes (probably).",
+];
+function pickUpdateQuip() {
+    return UPDATE_QUIPS[Math.floor(Math.random() * UPDATE_QUIPS.length)] ?? "Update complete.";
+}
+async function tryInstallShellCompletion(opts) {
+    if (opts.jsonMode || !process.stdin.isTTY) {
+        return;
+    }
+    const status = await checkShellCompletionStatus(CLI_NAME);
+    if (status.usesSlowPattern) {
+        defaultRuntime.log(theme.muted("Upgrading shell completion to cached version..."));
+        const cacheGenerated = await ensureCompletionCacheExists(CLI_NAME);
+        if (cacheGenerated) {
+            await installCompletion(status.shell, true, CLI_NAME);
+        }
+        return;
+    }
+    if (status.profileInstalled && !status.cacheExists) {
+        defaultRuntime.log(theme.muted("Regenerating shell completion cache..."));
+        await ensureCompletionCacheExists(CLI_NAME);
+        return;
+    }
+    if (!status.profileInstalled) {
+        defaultRuntime.log("");
+        defaultRuntime.log(theme.heading("Shell completion"));
+        const shouldInstall = await confirm({
+            message: stylePromptMessage(`Enable ${status.shell} shell completion for ${CLI_NAME}?`),
+            initialValue: true,
+        });
+        if (isCancel(shouldInstall) || !shouldInstall) {
+            if (!opts.skipPrompt) {
+                defaultRuntime.log(theme.muted(`Skipped. Run \`${replaceCliName(formatCliCommand("openclaw completion --install"), CLI_NAME)}\` later to enable.`));
+            }
+            return;
+        }
+        const cacheGenerated = await ensureCompletionCacheExists(CLI_NAME);
+        if (!cacheGenerated) {
+            defaultRuntime.log(theme.warn("Failed to generate completion cache."));
+            return;
+        }
+        await installCompletion(status.shell, opts.skipPrompt, CLI_NAME);
+    }
+}
+async function runPackageInstallUpdate(params) {
+    const manager = await resolveGlobalManager({
+        root: params.root,
+        installKind: params.installKind,
+        timeoutMs: params.timeoutMs,
+    });
+    const runCommand = async (argv, options) => {
+        const res = await runCommandWithTimeout(argv, options);
+        return { stdout: res.stdout, stderr: res.stderr, code: res.code };
+    };
+    const pkgRoot = await resolveGlobalPackageRoot(manager, runCommand, params.timeoutMs);
+    const packageName = (pkgRoot ? await readPackageName(pkgRoot) : await readPackageName(params.root)) ??
+        DEFAULT_PACKAGE_NAME;
+    const beforeVersion = pkgRoot ? await readPackageVersion(pkgRoot) : null;
+    if (pkgRoot) {
+        await cleanupGlobalRenameDirs({
+            globalRoot: path.dirname(pkgRoot),
+            packageName,
+        });
+    }
+    const updateStep = await runUpdateStep({
+        name: "global update",
+        argv: globalInstallArgs(manager, `${packageName}@${params.tag}`),
+        timeoutMs: params.timeoutMs,
+        progress: params.progress,
+    });
+    const steps = [updateStep];
+    let afterVersion = beforeVersion;
+    if (pkgRoot) {
+        afterVersion = await readPackageVersion(pkgRoot);
+        const entryPath = path.join(pkgRoot, "dist", "entry.js");
+        if (await pathExists(entryPath)) {
+            const doctorStep = await runUpdateStep({
+                name: `${CLI_NAME} doctor`,
+                argv: [resolveNodeRunner(), entryPath, "doctor", "--non-interactive"],
+                timeoutMs: params.timeoutMs,
+                progress: params.progress,
+            });
+            steps.push(doctorStep);
+        }
+    }
+    const failedStep = steps.find((step) => step.exitCode !== 0);
+    return {
+        status: failedStep ? "error" : "ok",
+        mode: manager,
+        root: pkgRoot ?? params.root,
+        reason: failedStep ? failedStep.name : undefined,
+        before: { version: beforeVersion },
+        after: { version: afterVersion },
+        steps,
+        durationMs: Date.now() - params.startedAt,
+    };
+}
+async function runGitUpdate(params) {
+    const updateRoot = params.switchToGit ? resolveGitInstallDir() : params.root;
+    const effectiveTimeout = params.timeoutMs ?? 20 * 60_000;
+    const cloneStep = params.switchToGit
+        ? await ensureGitCheckout({
+            dir: updateRoot,
+            timeoutMs: effectiveTimeout,
+            progress: params.progress,
+        })
+        : null;
+    if (cloneStep && cloneStep.exitCode !== 0) {
+        const result = {
+            status: "error",
+            mode: "git",
+            root: updateRoot,
+            reason: cloneStep.name,
+            steps: [cloneStep],
+            durationMs: Date.now() - params.startedAt,
+        };
+        params.stop();
+        printResult(result, { ...params.opts, hideSteps: params.showProgress });
+        defaultRuntime.exit(1);
+        return result;
+    }
+    const updateResult = await runGatewayUpdate({
+        cwd: updateRoot,
+        argv1: params.switchToGit ? undefined : process.argv[1],
+        timeoutMs: params.timeoutMs,
+        progress: params.progress,
+        channel: params.channel,
+        tag: params.tag,
+    });
+    const steps = [...(cloneStep ? [cloneStep] : []), ...updateResult.steps];
+    if (params.switchToGit && updateResult.status === "ok") {
+        const manager = await resolveGlobalManager({
+            root: params.root,
+            installKind: params.installKind,
+            timeoutMs: effectiveTimeout,
+        });
+        const installStep = await runUpdateStep({
+            name: "global install",
+            argv: globalInstallArgs(manager, updateRoot),
+            cwd: updateRoot,
+            timeoutMs: effectiveTimeout,
+            progress: params.progress,
+        });
+        steps.push(installStep);
+        const failedStep = installStep.exitCode !== 0 ? installStep : null;
+        return {
+            ...updateResult,
+            status: updateResult.status === "ok" && !failedStep ? "ok" : "error",
+            steps,
+            durationMs: Date.now() - params.startedAt,
+        };
+    }
+    return {
+        ...updateResult,
+        steps,
+        durationMs: Date.now() - params.startedAt,
+    };
+}
+async function updatePluginsAfterCoreUpdate(params) {
+    if (!params.configSnapshot.valid) {
+        if (!params.opts.json) {
+            defaultRuntime.log(theme.warn("Skipping plugin updates: config is invalid."));
+        }
+        return;
+    }
+    const pluginLogger = params.opts.json
+        ? {}
+        : {
+            info: (msg) => defaultRuntime.log(msg),
+            warn: (msg) => defaultRuntime.log(theme.warn(msg)),
+            error: (msg) => defaultRuntime.log(theme.error(msg)),
+        };
+    if (!params.opts.json) {
+        defaultRuntime.log("");
+        defaultRuntime.log(theme.heading("Updating plugins..."));
+    }
+    const syncResult = await syncPluginsForUpdateChannel({
+        config: params.configSnapshot.config,
+        channel: params.channel,
+        workspaceDir: params.root,
+        logger: pluginLogger,
+    });
+    let pluginConfig = syncResult.config;
+    const npmResult = await updateNpmInstalledPlugins({
+        config: pluginConfig,
+        skipIds: new Set(syncResult.summary.switchedToNpm),
+        logger: pluginLogger,
+    });
+    pluginConfig = npmResult.config;
+    if (syncResult.changed || npmResult.changed) {
+        await writeConfigFile(pluginConfig);
+    }
+    if (params.opts.json) {
+        return;
+    }
+    const summarizeList = (list) => {
+        if (list.length <= 6) {
+            return list.join(", ");
+        }
+        return `${list.slice(0, 6).join(", ")} +${list.length - 6} more`;
+    };
+    if (syncResult.summary.switchedToBundled.length > 0) {
+        defaultRuntime.log(theme.muted(`Switched to bundled plugins: ${summarizeList(syncResult.summary.switchedToBundled)}.`));
+    }
+    if (syncResult.summary.switchedToNpm.length > 0) {
+        defaultRuntime.log(theme.muted(`Restored npm plugins: ${summarizeList(syncResult.summary.switchedToNpm)}.`));
+    }
+    for (const warning of syncResult.summary.warnings) {
+        defaultRuntime.log(theme.warn(warning));
+    }
+    for (const error of syncResult.summary.errors) {
+        defaultRuntime.log(theme.error(error));
+    }
+    const updated = npmResult.outcomes.filter((entry) => entry.status === "updated").length;
+    const unchanged = npmResult.outcomes.filter((entry) => entry.status === "unchanged").length;
+    const failed = npmResult.outcomes.filter((entry) => entry.status === "error").length;
+    const skipped = npmResult.outcomes.filter((entry) => entry.status === "skipped").length;
+    if (npmResult.outcomes.length === 0) {
+        defaultRuntime.log(theme.muted("No plugin updates needed."));
+    }
+    else {
+        const parts = [`${updated} updated`, `${unchanged} unchanged`];
+        if (failed > 0) {
+            parts.push(`${failed} failed`);
+        }
+        if (skipped > 0) {
+            parts.push(`${skipped} skipped`);
+        }
+        defaultRuntime.log(theme.muted(`npm plugins: ${parts.join(", ")}.`));
+    }
+    for (const outcome of npmResult.outcomes) {
+        if (outcome.status !== "error") {
+            continue;
+        }
+        defaultRuntime.log(theme.error(outcome.message));
+    }
+}
+async function maybeRestartService(params) {
+    if (params.shouldRestart) {
+        if (!params.opts.json) {
+            defaultRuntime.log("");
+            defaultRuntime.log(theme.heading("Restarting service..."));
+        }
+        try {
+            let restarted = false;
+            if (params.restartScriptPath) {
+                await runRestartScript(params.restartScriptPath);
+                restarted = true;
+            }
+            else {
+                restarted = await runDaemonRestart();
+            }
+            if (!params.opts.json && restarted) {
+                defaultRuntime.log(theme.success("Daemon restarted successfully."));
+                defaultRuntime.log("");
+                process.env.POOLBOT_UPDATE_IN_PROGRESS = "1";
+                try {
+                    const interactiveDoctor = Boolean(process.stdin.isTTY) && !params.opts.json && params.opts.yes !== true;
+                    await doctorCommand(defaultRuntime, {
+                        nonInteractive: !interactiveDoctor,
+                    });
+                }
+                catch (err) {
+                    defaultRuntime.log(theme.warn(`Doctor failed: ${String(err)}`));
+                }
+                finally {
+                    delete process.env.POOLBOT_UPDATE_IN_PROGRESS;
+                }
+            }
+        }
+        catch (err) {
+            if (!params.opts.json) {
+                defaultRuntime.log(theme.warn(`Daemon restart failed: ${String(err)}`));
+                defaultRuntime.log(theme.muted(`You may need to restart the service manually: ${replaceCliName(formatCliCommand("openclaw gateway restart"), CLI_NAME)}`));
+            }
+        }
+        return;
+    }
+    if (!params.opts.json) {
+        defaultRuntime.log("");
+        if (params.result.mode === "npm" || params.result.mode === "pnpm") {
+            defaultRuntime.log(theme.muted(`Tip: Run \`${replaceCliName(formatCliCommand("openclaw doctor"), CLI_NAME)}\`, then \`${replaceCliName(formatCliCommand("openclaw gateway restart"), CLI_NAME)}\` to apply updates to a running gateway.`));
+        }
+        else {
+            defaultRuntime.log(theme.muted(`Tip: Run \`${replaceCliName(formatCliCommand("openclaw gateway restart"), CLI_NAME)}\` to apply updates to a running gateway.`));
+        }
+    }
+}
+export async function updateCommand(opts) {
+    suppressDeprecations();
+    const timeoutMs = opts.timeout ? Number.parseInt(opts.timeout, 10) * 1000 : undefined;
+    const shouldRestart = opts.restart !== false;
+    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 updateStatus = await checkUpdateStatus({
+        root,
+        timeoutMs: timeoutMs ?? 3500,
+        fetchGit: false,
+        includeRegistry: false,
+    });
+    const configSnapshot = await readConfigFileSnapshot();
+    const storedChannel = configSnapshot.valid
+        ? normalizeUpdateChannel(configSnapshot.config.update?.channel)
+        : null;
+    const requestedChannel = normalizeUpdateChannel(opts.channel);
+    if (opts.channel && !requestedChannel) {
+        defaultRuntime.error(`--channel must be "stable", "beta", or "dev" (got "${opts.channel}")`);
+        defaultRuntime.exit(1);
+        return;
+    }
+    if (opts.channel && !configSnapshot.valid) {
+        const issues = configSnapshot.issues.map((issue) => `- ${issue.path}: ${issue.message}`);
+        defaultRuntime.error(["Config is invalid; cannot set update channel.", ...issues].join("\n"));
+        defaultRuntime.exit(1);
+        return;
+    }
+    const installKind = updateStatus.installKind;
+    const switchToGit = requestedChannel === "dev" && installKind !== "git";
+    const switchToPackage = requestedChannel !== null && requestedChannel !== "dev" && installKind === "git";
+    const updateInstallKind = switchToGit ? "git" : switchToPackage ? "package" : installKind;
+    const defaultChannel = updateInstallKind === "git" ? DEFAULT_GIT_CHANNEL : DEFAULT_PACKAGE_CHANNEL;
+    const channel = requestedChannel ?? storedChannel ?? defaultChannel;
+    const explicitTag = normalizeTag(opts.tag);
+    let tag = explicitTag ?? channelToNpmTag(channel);
+    if (updateInstallKind !== "git") {
+        const currentVersion = switchToPackage ? null : await readPackageVersion(root);
+        let fallbackToLatest = false;
+        const targetVersion = explicitTag
+            ? await resolveTargetVersion(tag, timeoutMs)
+            : await resolveNpmChannelTag({ channel, timeoutMs }).then((resolved) => {
+                tag = resolved.tag;
+                fallbackToLatest = channel === "beta" && resolved.tag === "latest";
+                return resolved.version;
+            });
+        const cmp = currentVersion && targetVersion ? compareSemverStrings(currentVersion, targetVersion) : null;
+        const needsConfirm = !fallbackToLatest &&
+            currentVersion != null &&
+            (targetVersion == null || (cmp != null && cmp > 0));
+        if (needsConfirm && !opts.yes) {
+            if (!process.stdin.isTTY || opts.json) {
+                defaultRuntime.error([
+                    "Downgrade confirmation required.",
+                    "Downgrading can break configuration. Re-run in a TTY to confirm.",
+                ].join("\n"));
+                defaultRuntime.exit(1);
+                return;
+            }
+            const targetLabel = targetVersion ?? `${tag} (unknown)`;
+            const message = `Downgrading from ${currentVersion} to ${targetLabel} can break configuration. Continue?`;
+            const ok = await confirm({
+                message: stylePromptMessage(message),
+                initialValue: false,
+            });
+            if (isCancel(ok) || !ok) {
+                if (!opts.json) {
+                    defaultRuntime.log(theme.muted("Update cancelled."));
+                }
+                defaultRuntime.exit(0);
+                return;
+            }
+        }
+    }
+    else if (opts.tag && !opts.json) {
+        defaultRuntime.log(theme.muted("Note: --tag applies to npm installs only; git updates ignore it."));
+    }
+    if (requestedChannel && configSnapshot.valid) {
+        const next = {
+            ...configSnapshot.config,
+            update: {
+                ...configSnapshot.config.update,
+                channel: requestedChannel,
+            },
+        };
+        await writeConfigFile(next);
+        if (!opts.json) {
+            defaultRuntime.log(theme.muted(`Update channel set to ${requestedChannel}.`));
+        }
+    }
+    const showProgress = !opts.json && process.stdout.isTTY;
+    if (!opts.json) {
+        defaultRuntime.log(theme.heading("Updating OpenClaw..."));
+        defaultRuntime.log("");
+    }
+    const { progress, stop } = createUpdateProgress(showProgress);
+    const startedAt = Date.now();
+    let restartScriptPath = null;
+    if (shouldRestart) {
+        try {
+            const loaded = await resolveGatewayService().isLoaded({ env: process.env });
+            if (loaded) {
+                restartScriptPath = await prepareRestartScript(process.env);
+            }
+        }
+        catch {
+            // Ignore errors during pre-check; fallback to standard restart
+        }
+    }
+    const result = switchToPackage
+        ? await runPackageInstallUpdate({
+            root,
+            installKind,
+            tag,
+            timeoutMs: timeoutMs ?? 20 * 60_000,
+            startedAt,
+            progress,
+        })
+        : await runGitUpdate({
+            root,
+            switchToGit,
+            installKind,
+            timeoutMs,
+            startedAt,
+            progress,
+            channel,
+            tag,
+            showProgress,
+            opts,
+            stop,
+        });
+    stop();
+    printResult(result, { ...opts, hideSteps: showProgress });
+    if (result.status === "error") {
+        defaultRuntime.exit(1);
+        return;
+    }
+    if (result.status === "skipped") {
+        if (result.reason === "dirty") {
+            defaultRuntime.log(theme.warn("Skipped: working directory has uncommitted changes. Commit or stash them first."));
+        }
+        if (result.reason === "not-git-install") {
+            defaultRuntime.log(theme.warn(`Skipped: this OpenClaw install isn't a git checkout, and the package manager couldn't be detected. Update via your package manager, then run \`${replaceCliName(formatCliCommand("openclaw doctor"), CLI_NAME)}\` and \`${replaceCliName(formatCliCommand("openclaw gateway restart"), CLI_NAME)}\`.`));
+            defaultRuntime.log(theme.muted(`Examples: \`${replaceCliName("npm i -g openclaw@latest", CLI_NAME)}\` or \`${replaceCliName("pnpm add -g openclaw@latest", CLI_NAME)}\``));
+        }
+        defaultRuntime.exit(0);
+        return;
+    }
+    await updatePluginsAfterCoreUpdate({
+        root,
+        channel,
+        configSnapshot,
+        opts,
+    });
+    await tryWriteCompletionCache(root, Boolean(opts.json));
+    await tryInstallShellCompletion({
+        jsonMode: Boolean(opts.json),
+        skipPrompt: Boolean(opts.yes),
+    });
+    await maybeRestartService({
+        shouldRestart,
+        result,
+        opts,
+        restartScriptPath,
+    });
+    if (!opts.json) {
+        defaultRuntime.log(theme.muted(pickUpdateQuip()));
+    }
+}

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

@@ -0,0 +1,130 @@
+import { confirm, isCancel, select } from "@clack/prompts";
+import { readConfigFileSnapshot } from "../../config/config.js";
+import { formatUpdateChannelLabel, normalizeUpdateChannel, resolveEffectiveUpdateChannel, } from "../../infra/update-channels.js";
+import { checkUpdateStatus } from "../../infra/update-check.js";
+import { defaultRuntime } from "../../runtime.js";
+import { stylePromptHint, stylePromptMessage } from "../../terminal/prompt-style.js";
+import { theme } from "../../terminal/theme.js";
+import { pathExists } from "../../utils.js";
+import { isEmptyDir, isGitCheckout, resolveGitInstallDir, resolveUpdateRoot, } from "./shared.js";
+import { updateCommand } from "./update-command.js";
+const selectStyled = (params) => select({
+    ...params,
+    message: stylePromptMessage(params.message),
+    options: params.options.map((opt) => opt.hint === undefined ? opt : { ...opt, hint: stylePromptHint(opt.hint) }),
+});
+export async function updateWizardCommand(opts = {}) {
+    if (!process.stdin.isTTY) {
+        defaultRuntime.error("Update wizard requires a TTY. Use `openclaw update --channel <stable|beta|dev>` instead.");
+        defaultRuntime.exit(1);
+        return;
+    }
+    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 [updateStatus, configSnapshot] = await Promise.all([
+        checkUpdateStatus({
+            root,
+            timeoutMs: timeoutMs ?? 3500,
+            fetchGit: false,
+            includeRegistry: false,
+        }),
+        readConfigFileSnapshot(),
+    ]);
+    const configChannel = configSnapshot.valid
+        ? normalizeUpdateChannel(configSnapshot.config.update?.channel)
+        : null;
+    const channelInfo = resolveEffectiveUpdateChannel({
+        configChannel,
+        installKind: updateStatus.installKind,
+        git: updateStatus.git
+            ? { tag: updateStatus.git.tag, branch: updateStatus.git.branch }
+            : undefined,
+    });
+    const channelLabel = formatUpdateChannelLabel({
+        channel: channelInfo.channel,
+        source: channelInfo.source,
+        gitTag: updateStatus.git?.tag ?? null,
+        gitBranch: updateStatus.git?.branch ?? null,
+    });
+    const pickedChannel = await selectStyled({
+        message: "Update channel",
+        options: [
+            {
+                value: "keep",
+                label: `Keep current (${channelInfo.channel})`,
+                hint: channelLabel,
+            },
+            {
+                value: "stable",
+                label: "Stable",
+                hint: "Tagged releases (npm latest)",
+            },
+            {
+                value: "beta",
+                label: "Beta",
+                hint: "Prereleases (npm beta)",
+            },
+            {
+                value: "dev",
+                label: "Dev",
+                hint: "Git main",
+            },
+        ],
+        initialValue: "keep",
+    });
+    if (isCancel(pickedChannel)) {
+        defaultRuntime.log(theme.muted("Update cancelled."));
+        defaultRuntime.exit(0);
+        return;
+    }
+    const requestedChannel = pickedChannel === "keep" ? null : pickedChannel;
+    if (requestedChannel === "dev" && updateStatus.installKind !== "git") {
+        const gitDir = resolveGitInstallDir();
+        const hasGit = await isGitCheckout(gitDir);
+        if (!hasGit) {
+            const dirExists = await pathExists(gitDir);
+            if (dirExists) {
+                const empty = await isEmptyDir(gitDir);
+                if (!empty) {
+                    defaultRuntime.error(`POOLBOT_GIT_DIR points at a non-git directory: ${gitDir}. Set POOLBOT_GIT_DIR to an empty folder or an openclaw checkout.`);
+                    defaultRuntime.exit(1);
+                    return;
+                }
+            }
+            const ok = await confirm({
+                message: stylePromptMessage(`Create a git checkout at ${gitDir}? (override via POOLBOT_GIT_DIR)`),
+                initialValue: true,
+            });
+            if (isCancel(ok) || !ok) {
+                defaultRuntime.log(theme.muted("Update cancelled."));
+                defaultRuntime.exit(0);
+                return;
+            }
+        }
+    }
+    const restart = await confirm({
+        message: stylePromptMessage("Restart the gateway service after update?"),
+        initialValue: true,
+    });
+    if (isCancel(restart)) {
+        defaultRuntime.log(theme.muted("Update cancelled."));
+        defaultRuntime.exit(0);
+        return;
+    }
+    try {
+        await updateCommand({
+            channel: requestedChannel ?? undefined,
+            restart: Boolean(restart),
+            timeout: opts.timeout,
+        });
+    }
+    catch (err) {
+        defaultRuntime.error(String(err));
+        defaultRuntime.exit(1);
+    }
+}

package/dist/cli/update-cli.js

@@ -177,9 +177,7 @@ async function tryInstallShellCompletion(opts) {
         return;
     }
     try {
-        const { checkShellCompletionStatus, ensureCompletionCacheExists } = 
-        // @ts-expect-error module may not exist yet
-        await import("../commands/doctor-completion.js");
+        const { checkShellCompletionStatus, ensureCompletionCacheExists } = await import("../commands/doctor-completion.js");
         const status = await checkShellCompletionStatus(CLI_NAME);
         // Profile uses slow dynamic pattern - upgrade to cached version
         if (status.usesSlowPattern) {
@@ -188,9 +186,7 @@ async function tryInstallShellCompletion(opts) {
             const cacheGenerated = await ensureCompletionCacheExists(CLI_NAME);
             if (cacheGenerated) {
                 try {
-                    const { installCompletion } = 
-                    // @ts-expect-error module may not exist yet
-                    await import("./completion-cli.js");
+                    const { installCompletion } = await import("./completion-cli.js");
                     await installCompletion(status.shell, true, CLI_NAME);
                 }
                 catch {
@@ -226,9 +222,7 @@ async function tryInstallShellCompletion(opts) {
                 return;
             }
             try {
-                const { installCompletion } = 
-                // @ts-expect-error module may not exist yet
-                await import("./completion-cli.js");
+                const { installCompletion } = await import("./completion-cli.js");
                 await installCompletion(status.shell, opts.skipPrompt, CLI_NAME);
             }
             catch {