clawdbot 2026.1.4-1

package/dist/commands/onboard-helpers.js

@@ -0,0 +1,295 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { inspect } from "node:util";
+import { cancel, isCancel } from "@clack/prompts";
+import { DEFAULT_AGENT_WORKSPACE_DIR, ensureAgentWorkspace, } from "../agents/workspace.js";
+import { CONFIG_PATH_CLAWDBOT } from "../config/config.js";
+import { resolveSessionTranscriptsDir } from "../config/sessions.js";
+import { callGateway } from "../gateway/call.js";
+import { normalizeControlUiBasePath } from "../gateway/control-ui.js";
+import { pickPrimaryTailnetIPv4 } from "../infra/tailnet.js";
+import { runCommandWithTimeout } from "../process/exec.js";
+import { CONFIG_DIR, resolveUserPath } from "../utils.js";
+import { VERSION } from "../version.js";
+export function guardCancel(value, runtime) {
+    if (isCancel(value)) {
+        cancel("Setup cancelled.");
+        runtime.exit(0);
+    }
+    return value;
+}
+export function summarizeExistingConfig(config) {
+    const rows = [];
+    if (config.agent?.workspace)
+        rows.push(`workspace: ${config.agent.workspace}`);
+    if (config.agent?.model)
+        rows.push(`model: ${config.agent.model}`);
+    if (config.gateway?.mode)
+        rows.push(`gateway.mode: ${config.gateway.mode}`);
+    if (typeof config.gateway?.port === "number") {
+        rows.push(`gateway.port: ${config.gateway.port}`);
+    }
+    if (config.gateway?.bind)
+        rows.push(`gateway.bind: ${config.gateway.bind}`);
+    if (config.gateway?.remote?.url) {
+        rows.push(`gateway.remote.url: ${config.gateway.remote.url}`);
+    }
+    if (config.skills?.install?.nodeManager) {
+        rows.push(`skills.nodeManager: ${config.skills.install.nodeManager}`);
+    }
+    return rows.length ? rows.join("\n") : "No key settings detected.";
+}
+export function randomToken() {
+    return crypto.randomBytes(24).toString("hex");
+}
+export function printWizardHeader(runtime) {
+    const header = [
+        "░████░█░░░░░█████░█░░░█░███░░████░░████░░▀█▀",
+        "█░░░░░█░░░░░█░░░█░█░█░█░█░░█░█░░░█░█░░░█░░█░",
+        "█░░░░░█░░░░░█████░█░█░█░█░░█░████░░█░░░█░░█░",
+        "█░░░░░█░░░░░█░░░█░█░█░█░█░░█░█░░█░░█░░░█░░█░",
+        "░████░█████░█░░░█░░█░█░░███░░████░░░███░░░█░",
+        "              🦞 FRESH DAILY 🦞",
+    ].join("\n");
+    runtime.log(header);
+}
+export function applyWizardMetadata(cfg, params) {
+    const commit = process.env.GIT_COMMIT?.trim() || process.env.GIT_SHA?.trim() || undefined;
+    return {
+        ...cfg,
+        wizard: {
+            ...cfg.wizard,
+            lastRunAt: new Date().toISOString(),
+            lastRunVersion: VERSION,
+            lastRunCommit: commit,
+            lastRunCommand: params.command,
+            lastRunMode: params.mode,
+        },
+    };
+}
+let wslCached = null;
+async function isWSL() {
+    if (wslCached !== null)
+        return wslCached;
+    if (process.platform !== "linux") {
+        wslCached = false;
+        return wslCached;
+    }
+    if (process.env.WSL_INTEROP ||
+        process.env.WSL_DISTRO_NAME ||
+        process.env.WSLENV) {
+        wslCached = true;
+        return wslCached;
+    }
+    try {
+        const release = (await fs.readFile("/proc/version", "utf8")).toLowerCase();
+        wslCached = release.includes("microsoft") || release.includes("wsl");
+    }
+    catch {
+        wslCached = false;
+    }
+    return wslCached;
+}
+async function resolveBrowserOpenCommand() {
+    const platform = process.platform;
+    const hasDisplay = Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+    const isSsh = Boolean(process.env.SSH_CLIENT) ||
+        Boolean(process.env.SSH_TTY) ||
+        Boolean(process.env.SSH_CONNECTION);
+    if (isSsh && !hasDisplay && platform !== "win32") {
+        return { argv: null, reason: "ssh-no-display" };
+    }
+    if (platform === "win32") {
+        return { argv: ["cmd", "/c", "start", ""], command: "cmd" };
+    }
+    if (platform === "darwin") {
+        const hasOpen = await detectBinary("open");
+        return hasOpen
+            ? { argv: ["open"], command: "open" }
+            : { argv: null, reason: "missing-open" };
+    }
+    if (platform === "linux") {
+        const wsl = await isWSL();
+        if (!hasDisplay && !wsl) {
+            return { argv: null, reason: "no-display" };
+        }
+        if (wsl) {
+            const hasWslview = await detectBinary("wslview");
+            if (hasWslview)
+                return { argv: ["wslview"], command: "wslview" };
+            if (!hasDisplay)
+                return { argv: null, reason: "wsl-no-wslview" };
+        }
+        const hasXdgOpen = await detectBinary("xdg-open");
+        return hasXdgOpen
+            ? { argv: ["xdg-open"], command: "xdg-open" }
+            : { argv: null, reason: "missing-xdg-open" };
+    }
+    return { argv: null, reason: "unsupported-platform" };
+}
+export async function detectBrowserOpenSupport() {
+    const resolved = await resolveBrowserOpenCommand();
+    if (!resolved.argv)
+        return { ok: false, reason: resolved.reason };
+    return { ok: true, command: resolved.command };
+}
+export function formatControlUiSshHint(params) {
+    const basePath = normalizeControlUiBasePath(params.basePath);
+    const uiPath = basePath ? `${basePath}/` : "/";
+    const localUrl = `http://localhost:${params.port}${uiPath}`;
+    const tokenParam = params.token
+        ? `?token=${encodeURIComponent(params.token)}`
+        : "";
+    const authedUrl = params.token ? `${localUrl}${tokenParam}` : undefined;
+    const sshTarget = resolveSshTargetHint();
+    return [
+        "No GUI detected. Open from your computer:",
+        `ssh -N -L ${params.port}:127.0.0.1:${params.port} ${sshTarget}`,
+        "Then open:",
+        localUrl,
+        authedUrl,
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+function resolveSshTargetHint() {
+    const user = process.env.USER || process.env.LOGNAME || "user";
+    const conn = process.env.SSH_CONNECTION?.trim().split(/\s+/);
+    const host = conn?.[2] ?? "<host>";
+    return `${user}@${host}`;
+}
+export async function openUrl(url) {
+    const resolved = await resolveBrowserOpenCommand();
+    if (!resolved.argv)
+        return false;
+    const command = [...resolved.argv, url];
+    try {
+        await runCommandWithTimeout(command, { timeoutMs: 5_000 });
+        return true;
+    }
+    catch {
+        // ignore; we still print the URL for manual open
+        return false;
+    }
+}
+export async function ensureWorkspaceAndSessions(workspaceDir, runtime) {
+    const ws = await ensureAgentWorkspace({
+        dir: workspaceDir,
+        ensureBootstrapFiles: true,
+    });
+    runtime.log(`Workspace OK: ${ws.dir}`);
+    const sessionsDir = resolveSessionTranscriptsDir();
+    await fs.mkdir(sessionsDir, { recursive: true });
+    runtime.log(`Sessions OK: ${sessionsDir}`);
+}
+export function resolveNodeManagerOptions() {
+    return [
+        { value: "npm", label: "npm" },
+        { value: "pnpm", label: "pnpm" },
+        { value: "bun", label: "bun" },
+    ];
+}
+export async function moveToTrash(pathname, runtime) {
+    if (!pathname)
+        return;
+    try {
+        await fs.access(pathname);
+    }
+    catch {
+        return;
+    }
+    try {
+        await runCommandWithTimeout(["trash", pathname], { timeoutMs: 5000 });
+        runtime.log(`Moved to Trash: ${pathname}`);
+    }
+    catch {
+        runtime.log(`Failed to move to Trash (manual delete): ${pathname}`);
+    }
+}
+export async function handleReset(scope, workspaceDir, runtime) {
+    await moveToTrash(CONFIG_PATH_CLAWDBOT, runtime);
+    if (scope === "config")
+        return;
+    await moveToTrash(path.join(CONFIG_DIR, "credentials"), runtime);
+    await moveToTrash(resolveSessionTranscriptsDir(), runtime);
+    if (scope === "full") {
+        await moveToTrash(workspaceDir, runtime);
+    }
+}
+export async function detectBinary(name) {
+    if (!name?.trim())
+        return false;
+    const resolved = name.startsWith("~") ? resolveUserPath(name) : name;
+    if (path.isAbsolute(resolved) || resolved.startsWith(".")) {
+        try {
+            await fs.access(resolved);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    const command = process.platform === "win32"
+        ? ["where", name]
+        : ["/usr/bin/env", "sh", "-lc", `command -v ${name}`];
+    try {
+        const result = await runCommandWithTimeout(command, { timeoutMs: 2000 });
+        return result.code === 0 && result.stdout.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+export async function probeGatewayReachable(params) {
+    const url = params.url.trim();
+    const timeoutMs = params.timeoutMs ?? 1500;
+    try {
+        await callGateway({
+            url,
+            token: params.token,
+            password: params.password,
+            method: "health",
+            timeoutMs,
+            clientName: "clawdbot-probe",
+            mode: "probe",
+        });
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, detail: summarizeError(err) };
+    }
+}
+function summarizeError(err) {
+    let raw = "unknown error";
+    if (err instanceof Error) {
+        raw = err.message || raw;
+    }
+    else if (typeof err === "string") {
+        raw = err || raw;
+    }
+    else if (err !== undefined) {
+        raw = inspect(err, { depth: 2 });
+    }
+    const line = raw
+        .split("\n")
+        .map((s) => s.trim())
+        .find(Boolean) ?? raw;
+    return line.length > 120 ? `${line.slice(0, 119)}…` : line;
+}
+export const DEFAULT_WORKSPACE = DEFAULT_AGENT_WORKSPACE_DIR;
+export function resolveControlUiLinks(params) {
+    const port = params.port;
+    const bind = params.bind ?? "loopback";
+    const tailnetIPv4 = pickPrimaryTailnetIPv4();
+    const host = bind === "tailnet" || (bind === "auto" && tailnetIPv4)
+        ? (tailnetIPv4 ?? "127.0.0.1")
+        : "127.0.0.1";
+    const basePath = normalizeControlUiBasePath(params.basePath);
+    const uiPath = basePath ? `${basePath}/` : "/";
+    const wsPath = basePath ? basePath : "";
+    return {
+        httpUrl: `http://${host}:${port}${uiPath}`,
+        wsUrl: `ws://${host}:${port}${wsPath}`,
+    };
+}

package/dist/commands/onboard-interactive.js

@@ -0,0 +1,17 @@
+import { defaultRuntime } from "../runtime.js";
+import { createClackPrompter } from "../wizard/clack-prompter.js";
+import { runOnboardingWizard } from "../wizard/onboarding.js";
+import { WizardCancelledError } from "../wizard/prompts.js";
+export async function runInteractiveOnboarding(opts, runtime = defaultRuntime) {
+    const prompter = createClackPrompter();
+    try {
+        await runOnboardingWizard(opts, runtime, prompter);
+    }
+    catch (err) {
+        if (err instanceof WizardCancelledError) {
+            runtime.exit(0);
+            return;
+        }
+        throw err;
+    }
+}

package/dist/commands/onboard-non-interactive.js

@@ -0,0 +1,202 @@
+import path from "node:path";
+import { CONFIG_PATH_CLAWDBOT, readConfigFileSnapshot, resolveGatewayPort, writeConfigFile, } from "../config/config.js";
+import { GATEWAY_LAUNCH_AGENT_LABEL } from "../daemon/constants.js";
+import { resolveGatewayProgramArguments } from "../daemon/program-args.js";
+import { resolveGatewayService } from "../daemon/service.js";
+import { defaultRuntime } from "../runtime.js";
+import { resolveUserPath, sleep } from "../utils.js";
+import { healthCommand } from "./health.js";
+import { applyMinimaxConfig, setAnthropicApiKey } from "./onboard-auth.js";
+import { applyWizardMetadata, DEFAULT_WORKSPACE, ensureWorkspaceAndSessions, randomToken, } from "./onboard-helpers.js";
+export async function runNonInteractiveOnboarding(opts, runtime = defaultRuntime) {
+    const snapshot = await readConfigFileSnapshot();
+    const baseConfig = snapshot.valid ? snapshot.config : {};
+    const mode = opts.mode ?? "local";
+    if (mode === "remote") {
+        const remoteUrl = opts.remoteUrl?.trim();
+        if (!remoteUrl) {
+            runtime.error("Missing --remote-url for remote mode.");
+            runtime.exit(1);
+            return;
+        }
+        let nextConfig = {
+            ...baseConfig,
+            gateway: {
+                ...baseConfig.gateway,
+                mode: "remote",
+                remote: {
+                    url: remoteUrl,
+                    token: opts.remoteToken?.trim() || undefined,
+                },
+            },
+        };
+        nextConfig = applyWizardMetadata(nextConfig, { command: "onboard", mode });
+        await writeConfigFile(nextConfig);
+        runtime.log(`Updated ${CONFIG_PATH_CLAWDBOT}`);
+        const payload = {
+            mode,
+            remoteUrl,
+            auth: opts.remoteToken ? "token" : "none",
+        };
+        if (opts.json) {
+            runtime.log(JSON.stringify(payload, null, 2));
+        }
+        else {
+            runtime.log(`Remote gateway: ${remoteUrl}`);
+            runtime.log(`Auth: ${payload.auth}`);
+        }
+        return;
+    }
+    const workspaceDir = resolveUserPath((opts.workspace ?? baseConfig.agent?.workspace ?? DEFAULT_WORKSPACE).trim());
+    let nextConfig = {
+        ...baseConfig,
+        agent: {
+            ...baseConfig.agent,
+            workspace: workspaceDir,
+        },
+        gateway: {
+            ...baseConfig.gateway,
+            mode: "local",
+        },
+    };
+    const authChoice = opts.authChoice ?? "skip";
+    if (authChoice === "apiKey") {
+        const key = opts.anthropicApiKey?.trim();
+        if (!key) {
+            runtime.error("Missing --anthropic-api-key");
+            runtime.exit(1);
+            return;
+        }
+        await setAnthropicApiKey(key);
+    }
+    else if (authChoice === "minimax") {
+        nextConfig = applyMinimaxConfig(nextConfig);
+    }
+    else if (authChoice === "oauth" || authChoice === "antigravity") {
+        runtime.error(`${authChoice === "oauth" ? "OAuth" : "Antigravity"} requires interactive mode.`);
+        runtime.exit(1);
+        return;
+    }
+    const hasGatewayPort = opts.gatewayPort !== undefined;
+    if (hasGatewayPort &&
+        (!Number.isFinite(opts.gatewayPort) || (opts.gatewayPort ?? 0) <= 0)) {
+        runtime.error("Invalid --gateway-port");
+        runtime.exit(1);
+        return;
+    }
+    const port = hasGatewayPort
+        ? opts.gatewayPort
+        : resolveGatewayPort(baseConfig);
+    let bind = opts.gatewayBind ?? "loopback";
+    let authMode = opts.gatewayAuth ?? "off";
+    const tailscaleMode = opts.tailscale ?? "off";
+    const tailscaleResetOnExit = Boolean(opts.tailscaleResetOnExit);
+    if (tailscaleMode !== "off" && bind !== "loopback") {
+        bind = "loopback";
+    }
+    if (authMode === "off" && bind !== "loopback") {
+        authMode = "token";
+    }
+    if (tailscaleMode === "funnel" && authMode !== "password") {
+        authMode = "password";
+    }
+    let gatewayToken = opts.gatewayToken?.trim() || undefined;
+    if (authMode === "token") {
+        if (!gatewayToken)
+            gatewayToken = randomToken();
+        nextConfig = {
+            ...nextConfig,
+            gateway: {
+                ...nextConfig.gateway,
+                auth: { ...nextConfig.gateway?.auth, mode: "token" },
+            },
+        };
+    }
+    if (authMode === "password") {
+        const password = opts.gatewayPassword?.trim();
+        if (!password) {
+            runtime.error("Missing --gateway-password for password auth.");
+            runtime.exit(1);
+            return;
+        }
+        nextConfig = {
+            ...nextConfig,
+            gateway: {
+                ...nextConfig.gateway,
+                auth: {
+                    ...nextConfig.gateway?.auth,
+                    mode: "password",
+                    password,
+                },
+            },
+        };
+    }
+    nextConfig = {
+        ...nextConfig,
+        gateway: {
+            ...nextConfig.gateway,
+            port,
+            bind,
+            tailscale: {
+                ...nextConfig.gateway?.tailscale,
+                mode: tailscaleMode,
+                resetOnExit: tailscaleResetOnExit,
+            },
+        },
+    };
+    if (!opts.skipSkills) {
+        const nodeManager = opts.nodeManager ?? "npm";
+        if (!["npm", "pnpm", "bun"].includes(nodeManager)) {
+            runtime.error("Invalid --node-manager (use npm, pnpm, or bun)");
+            runtime.exit(1);
+            return;
+        }
+        nextConfig = {
+            ...nextConfig,
+            skills: {
+                ...nextConfig.skills,
+                install: {
+                    ...nextConfig.skills?.install,
+                    nodeManager,
+                },
+            },
+        };
+    }
+    nextConfig = applyWizardMetadata(nextConfig, { command: "onboard", mode });
+    await writeConfigFile(nextConfig);
+    runtime.log(`Updated ${CONFIG_PATH_CLAWDBOT}`);
+    await ensureWorkspaceAndSessions(workspaceDir, runtime);
+    if (opts.installDaemon) {
+        const service = resolveGatewayService();
+        const devMode = process.argv[1]?.includes(`${path.sep}src${path.sep}`) &&
+            process.argv[1]?.endsWith(".ts");
+        const { programArguments, workingDirectory } = await resolveGatewayProgramArguments({ port, dev: devMode });
+        const environment = {
+            PATH: process.env.PATH,
+            CLAWDBOT_GATEWAY_TOKEN: gatewayToken,
+            CLAWDBOT_LAUNCHD_LABEL: process.platform === "darwin" ? GATEWAY_LAUNCH_AGENT_LABEL : undefined,
+        };
+        await service.install({
+            env: process.env,
+            stdout: process.stdout,
+            programArguments,
+            workingDirectory,
+            environment,
+        });
+    }
+    if (!opts.skipHealth) {
+        await sleep(1000);
+        await healthCommand({ json: false, timeoutMs: 10_000 }, runtime);
+    }
+    if (opts.json) {
+        runtime.log(JSON.stringify({
+            mode,
+            workspace: workspaceDir,
+            authChoice,
+            gateway: { port, bind, authMode, tailscaleMode },
+            installDaemon: Boolean(opts.installDaemon),
+            skipSkills: Boolean(opts.skipSkills),
+            skipHealth: Boolean(opts.skipHealth),
+        }, null, 2));
+    }
+}