openclaw-manager 0.1.1

package/dist/lib/auth.js

@@ -0,0 +1,57 @@
+import { scryptSync, timingSafeEqual } from "node:crypto";
+import fs from "node:fs";
+import { resolveConfigPath } from "./config.js";
+export function resolveAuthState(authDisabled) {
+    if (authDisabled) {
+        return { configured: false, verify: () => true };
+    }
+    const envUser = process.env.MANAGER_AUTH_USERNAME?.trim() ?? "";
+    const envPass = process.env.MANAGER_AUTH_PASSWORD ?? "";
+    if (envUser && envPass) {
+        return {
+            configured: true,
+            verify: (username, password) => username === envUser && password === envPass
+        };
+    }
+    const config = loadManagerConfig();
+    const auth = config?.auth;
+    if (!auth?.username || !auth?.salt || !auth?.hash) {
+        return { configured: false, verify: () => false };
+    }
+    return {
+        configured: true,
+        verify: (username, password) => verifyPassword(username, password, auth)
+    };
+}
+export function verifyAuthHeader(header, authState) {
+    const match = header.match(/^Basic\s+(.+)$/i);
+    if (!match)
+        return false;
+    const decoded = Buffer.from(match[1], "base64").toString("utf-8");
+    const [username, ...rest] = decoded.split(":");
+    const password = rest.join(":");
+    if (!username || !password)
+        return false;
+    return authState.verify(username, password);
+}
+function verifyPassword(username, password, auth) {
+    if (username !== auth.username)
+        return false;
+    const hashed = scryptSync(password, auth.salt, 64);
+    const expected = Buffer.from(auth.hash, "base64");
+    if (hashed.length !== expected.length)
+        return false;
+    return timingSafeEqual(hashed, expected);
+}
+function loadManagerConfig() {
+    const configPath = resolveConfigPath();
+    try {
+        if (!fs.existsSync(configPath))
+            return null;
+        const raw = fs.readFileSync(configPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/commands.js

@@ -0,0 +1,123 @@
+import { spawn } from "node:child_process";
+export function buildCommandRegistry(root) {
+    return [
+        {
+            id: "install-cli",
+            title: "Install Clawdbot CLI",
+            description: "Install the latest Clawdbot CLI (may require sudo)",
+            command: "npm",
+            args: ["i", "-g", "clawdbot@latest"],
+            cwd: root,
+            allowRun: true
+        },
+        {
+            id: "gateway-run",
+            title: "Start gateway",
+            description: "Run the local gateway (loopback only)",
+            command: "clawdbot",
+            args: ["gateway", "run", "--allow-unconfigured", "--bind", "loopback", "--port", "18789", "--force"],
+            cwd: root,
+            allowRun: true
+        },
+        {
+            id: "channels-probe",
+            title: "Probe channels",
+            description: "Check channel connectivity",
+            command: "clawdbot",
+            args: ["channels", "status", "--probe"],
+            cwd: root,
+            allowRun: true
+        }
+    ];
+}
+export function createProcessManager(commandRegistry) {
+    const processRegistry = new Map();
+    const listProcesses = () => {
+        return commandRegistry.map((cmd) => {
+            const managed = processRegistry.get(cmd.id);
+            return snapshotProcess(cmd, managed ?? null);
+        });
+    };
+    const startProcess = (id, options) => {
+        const def = commandRegistry.find((cmd) => cmd.id === id);
+        if (!def)
+            return { ok: false, error: "unknown id" };
+        if (!def.allowRun)
+            return { ok: false, error: "not allowed" };
+        const existing = processRegistry.get(id);
+        if (existing?.child && !existing.child.killed && existing.exitCode == null) {
+            return { ok: true, process: snapshotProcess(def, existing) };
+        }
+        const args = options?.args ?? def.args;
+        const child = spawn(def.command, args, {
+            cwd: def.cwd,
+            env: options?.env ?? process.env
+        });
+        const managed = {
+            def,
+            args,
+            child,
+            logs: [],
+            startedAt: new Date(),
+            exitCode: null
+        };
+        processRegistry.set(id, managed);
+        const pushLog = (chunk) => {
+            const lines = chunk.split(/\r?\n/).filter(Boolean);
+            if (!lines.length)
+                return;
+            const clipped = lines.map((line) => line.slice(0, 1000));
+            managed.logs.push(...clipped);
+            for (const line of clipped) {
+                options?.onLog?.(line);
+            }
+            if (managed.logs.length > 200) {
+                managed.logs.splice(0, managed.logs.length - 200);
+            }
+        };
+        child.stdout?.on("data", (chunk) => pushLog(chunk.toString()));
+        child.stderr?.on("data", (chunk) => pushLog(chunk.toString()));
+        child.on("error", (err) => {
+            managed.exitCode = 1;
+            pushLog(`spawn error: ${err.message}`);
+        });
+        child.on("close", (code) => {
+            managed.exitCode = code ?? null;
+        });
+        return { ok: true, process: snapshotProcess(def, managed) };
+    };
+    const stopProcess = (id) => {
+        const def = commandRegistry.find((cmd) => cmd.id === id);
+        if (!def)
+            return { ok: false, error: "unknown id" };
+        const managed = processRegistry.get(id);
+        if (!managed?.child) {
+            return { ok: true, process: snapshotProcess(def, managed ?? null) };
+        }
+        managed.child.kill("SIGTERM");
+        setTimeout(() => {
+            if (managed.child && !managed.child.killed) {
+                managed.child.kill("SIGKILL");
+            }
+        }, 2000);
+        return { ok: true, process: snapshotProcess(def, managed) };
+    };
+    return { listProcesses, startProcess, stopProcess };
+}
+function snapshotProcess(def, managed) {
+    const running = Boolean(managed?.child && !managed.child.killed && managed.exitCode == null);
+    return {
+        id: def.id,
+        title: def.title,
+        command: formatCommand(def, managed?.args),
+        cwd: def.cwd,
+        running,
+        pid: managed?.child?.pid ?? null,
+        startedAt: managed?.startedAt?.toISOString() ?? null,
+        exitCode: managed?.exitCode ?? null,
+        lastLines: managed?.logs.slice(-20) ?? []
+    };
+}
+function formatCommand(cmd, argsOverride) {
+    return [cmd.command, ...(argsOverride ?? cmd.args)].join(" ");
+}

package/dist/lib/config.js

@@ -0,0 +1,48 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { DEFAULT_CONFIG_PATH } from "./constants.js";
+export function resolveRepoRoot() {
+    const envRoot = process.env.MANAGER_REPO_ROOT ?? process.env.ONBOARDING_REPO_ROOT;
+    if (envRoot)
+        return path.resolve(envRoot);
+    const startPoints = [process.cwd(), path.dirname(fileURLToPath(import.meta.url))];
+    for (const start of startPoints) {
+        const found = findRepoRoot(start);
+        if (found)
+            return found;
+    }
+    return path.resolve(process.cwd(), "../..");
+}
+export function resolveWebDist(root) {
+    const candidate = process.env.MANAGER_WEB_DIST ?? path.join(root, "apps/web/dist");
+    const indexPath = path.join(candidate, "index.html");
+    if (fs.existsSync(indexPath))
+        return candidate;
+    return null;
+}
+export function resolveConfigPath() {
+    return process.env.MANAGER_CONFIG_PATH ?? DEFAULT_CONFIG_PATH;
+}
+function findRepoRoot(start) {
+    let current = start;
+    for (let i = 0; i < 6; i += 1) {
+        const candidate = path.join(current, "package.json");
+        if (fs.existsSync(candidate)) {
+            try {
+                const raw = fs.readFileSync(candidate, "utf-8");
+                const parsed = JSON.parse(raw);
+                if (parsed.name === "clawdbot-manager")
+                    return current;
+            }
+            catch {
+                return current;
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}

package/dist/lib/constants.js

@@ -0,0 +1,9 @@
+import os from "node:os";
+import path from "node:path";
+export const REQUIRED_NODE_MAJOR = 22;
+export const DEFAULT_GATEWAY_HOST = "127.0.0.1";
+export const DEFAULT_GATEWAY_PORT = 18789;
+export const DEFAULT_API_HOST = "127.0.0.1";
+export const DEFAULT_API_PORT = 17321;
+export const DEFAULT_CONFIG_PATH = path.join(os.homedir(), ".clawdbot-manager", "config.json");
+export const ONBOARDING_CACHE_MS = 5000;

package/dist/lib/gateway.js

@@ -0,0 +1,37 @@
+import net from "node:net";
+import { sleep } from "./utils.js";
+export async function checkGateway(host, port) {
+    const start = Date.now();
+    return new Promise((resolve) => {
+        const socket = new net.Socket();
+        let finished = false;
+        const finish = (ok, error) => {
+            if (finished)
+                return;
+            finished = true;
+            socket.destroy();
+            resolve({
+                ok,
+                host,
+                port,
+                latencyMs: ok ? Date.now() - start : null,
+                error: error ?? null
+            });
+        };
+        socket.setTimeout(1200);
+        socket.once("connect", () => finish(true));
+        socket.once("timeout", () => finish(false, "timeout"));
+        socket.once("error", (err) => finish(false, err.message));
+        socket.connect(port, host);
+    });
+}
+export async function waitForGateway(host, port, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const res = await checkGateway(host, port);
+        if (res.ok)
+            return true;
+        await sleep(400);
+    }
+    return false;
+}

package/dist/lib/jobs.js

@@ -0,0 +1,117 @@
+import crypto from "node:crypto";
+const MAX_LOGS = 200;
+const JOB_TTL_MS = 10 * 60 * 1000;
+export function createJobStore() {
+    const jobs = new Map();
+    const listeners = new Map();
+    const cleanup = () => {
+        const now = Date.now();
+        for (const [id, job] of jobs.entries()) {
+            if (job.expiresAt && job.expiresAt <= now) {
+                jobs.delete(id);
+                listeners.delete(id);
+            }
+        }
+    };
+    const emit = (id, event) => {
+        const subs = listeners.get(id);
+        if (!subs || subs.size === 0)
+            return;
+        for (const listener of subs) {
+            listener(event);
+        }
+    };
+    const getOrThrow = (id) => {
+        const job = jobs.get(id);
+        if (!job)
+            return null;
+        return job;
+    };
+    return {
+        createJob: (title) => {
+            cleanup();
+            const id = crypto.randomUUID();
+            const now = new Date().toISOString();
+            const entry = {
+                id,
+                title,
+                status: "pending",
+                createdAt: now,
+                startedAt: null,
+                endedAt: null,
+                logs: [],
+                error: null,
+                result: null,
+                expiresAt: null
+            };
+            jobs.set(id, entry);
+            return { ...entry };
+        },
+        startJob: (id) => {
+            const job = getOrThrow(id);
+            if (!job)
+                return;
+            job.status = "running";
+            job.startedAt = new Date().toISOString();
+            emit(id, { type: "status", status: job.status });
+        },
+        appendLog: (id, message) => {
+            const job = getOrThrow(id);
+            if (!job)
+                return;
+            if (!message.trim())
+                return;
+            job.logs.push(message.slice(0, 2000));
+            if (job.logs.length > MAX_LOGS) {
+                job.logs.splice(0, job.logs.length - MAX_LOGS);
+            }
+            emit(id, { type: "log", message });
+        },
+        completeJob: (id, result) => {
+            const job = getOrThrow(id);
+            if (!job)
+                return;
+            job.status = "success";
+            job.endedAt = new Date().toISOString();
+            job.result = result ?? null;
+            job.expiresAt = Date.now() + JOB_TTL_MS;
+            emit(id, { type: "status", status: job.status });
+            emit(id, { type: "done", result: job.result ?? undefined });
+        },
+        failJob: (id, error) => {
+            const job = getOrThrow(id);
+            if (!job)
+                return;
+            job.status = "failed";
+            job.endedAt = new Date().toISOString();
+            job.error = error;
+            job.expiresAt = Date.now() + JOB_TTL_MS;
+            emit(id, { type: "status", status: job.status });
+            emit(id, { type: "error", error });
+        },
+        getJob: (id) => {
+            cleanup();
+            const job = jobs.get(id);
+            if (!job)
+                return null;
+            return { ...job };
+        },
+        subscribe: (id, listener) => {
+            const job = jobs.get(id);
+            if (!job)
+                return () => { };
+            const set = listeners.get(id) ?? new Set();
+            set.add(listener);
+            listeners.set(id, set);
+            return () => {
+                const current = listeners.get(id);
+                if (!current)
+                    return;
+                current.delete(listener);
+                if (current.size === 0) {
+                    listeners.delete(id);
+                }
+            };
+        }
+    };
+}

package/dist/lib/onboarding.js

@@ -0,0 +1,96 @@
+import { ONBOARDING_CACHE_MS } from "./constants.js";
+let onboardingCache = null;
+let lastProbe = null;
+export function setLastProbe(ok) {
+    lastProbe = { ok, at: new Date().toISOString() };
+}
+export async function getOnboardingStatus(cliInstalled, runCommand) {
+    const now = Date.now();
+    if (onboardingCache && now - onboardingCache.at < ONBOARDING_CACHE_MS) {
+        return onboardingCache.data;
+    }
+    if (!cliInstalled) {
+        const data = {
+            discord: {
+                tokenConfigured: false,
+                allowFromConfigured: false,
+                pendingPairings: 0
+            },
+            ai: {
+                configured: false,
+                missingProviders: []
+            },
+            probe: lastProbe
+        };
+        onboardingCache = { at: now, data };
+        return data;
+    }
+    const [tokenConfigured, allowFromConfigured, pendingPairings, aiStatus] = await Promise.all([
+        readDiscordTokenConfigured(runCommand),
+        readDiscordAllowFromConfigured(runCommand),
+        readPendingDiscordPairings(runCommand),
+        readAiAuthStatus(runCommand)
+    ]);
+    const data = {
+        discord: {
+            tokenConfigured,
+            allowFromConfigured,
+            pendingPairings
+        },
+        ai: aiStatus,
+        probe: lastProbe
+    };
+    onboardingCache = { at: now, data };
+    return data;
+}
+async function readConfigValue(runCommand, pathKey) {
+    try {
+        const output = await runCommand("clawdbot", ["config", "get", pathKey, "--json"], 4000);
+        return JSON.parse(output);
+    }
+    catch {
+        return null;
+    }
+}
+async function readDiscordTokenConfigured(runCommand) {
+    const value = await readConfigValue(runCommand, "channels.discord.token");
+    return typeof value === "string" ? value.trim().length > 0 : false;
+}
+async function readDiscordAllowFromConfigured(runCommand) {
+    const value = await readConfigValue(runCommand, "channels.discord.dm.allowFrom");
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (value === "*")
+        return true;
+    return false;
+}
+async function readPendingDiscordPairings(runCommand) {
+    try {
+        const output = await runCommand("clawdbot", ["pairing", "list", "--channel", "discord", "--json"], 4000);
+        const parsed = JSON.parse(output);
+        return Array.isArray(parsed?.requests) ? parsed.requests.length : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+async function readAiAuthStatus(runCommand) {
+    try {
+        const output = await runCommand("clawdbot", ["models", "status", "--json"], 8000);
+        const parsed = JSON.parse(output);
+        const missing = Array.isArray(parsed?.auth?.missingProvidersInUse)
+            ? parsed.auth?.missingProvidersInUse.map((item) => String(item))
+            : [];
+        return {
+            configured: missing.length === 0,
+            missingProviders: missing
+        };
+    }
+    catch (err) {
+        return {
+            configured: false,
+            missingProviders: [],
+            error: err instanceof Error ? err.message : String(err)
+        };
+    }
+}

package/dist/lib/runner.js

@@ -0,0 +1,99 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+export function createCommandRunner(repoRoot) {
+    return (cmd, args, timeoutMs, env = process.env) => runCommand(cmd, args, timeoutMs, { cwd: repoRoot, env });
+}
+export function findOnPath(binary) {
+    const envPath = process.env.PATH ?? "";
+    const entries = envPath.split(path.delimiter).filter(Boolean);
+    for (const entry of entries) {
+        const candidate = path.join(entry, binary);
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+export function runCommandWithLogs(cmd, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            cwd: options.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: options.env
+        });
+        let stdoutBuffer = "";
+        let stderrBuffer = "";
+        const flushLines = (buffer, prefix) => {
+            const lines = buffer.split(/\r?\n/);
+            const rest = lines.pop() ?? "";
+            for (const line of lines) {
+                const trimmed = line.trimEnd();
+                if (trimmed) {
+                    options.onLog(prefix ? `${prefix}${trimmed}` : trimmed);
+                }
+            }
+            return rest;
+        };
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            reject(new Error("timeout"));
+        }, options.timeoutMs);
+        child.stdout?.on("data", (chunk) => {
+            stdoutBuffer += chunk.toString();
+            stdoutBuffer = flushLines(stdoutBuffer);
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderrBuffer += chunk.toString();
+            stderrBuffer = flushLines(stderrBuffer, "stderr: ");
+        });
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (stdoutBuffer.trim()) {
+                options.onLog(stdoutBuffer.trimEnd());
+            }
+            if (stderrBuffer.trim()) {
+                options.onLog(`stderr: ${stderrBuffer.trimEnd()}`);
+            }
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`exit ${code ?? "unknown"}`));
+        });
+    });
+}
+function runCommand(cmd, args, timeoutMs, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            cwd: options.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: options.env
+        });
+        let output = "";
+        let error = "";
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            reject(new Error("timeout"));
+        }, timeoutMs);
+        child.stdout?.on("data", (chunk) => {
+            output += chunk.toString();
+        });
+        child.stderr?.on("data", (chunk) => {
+            error += chunk.toString();
+        });
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (code === 0)
+                resolve(output);
+            else
+                reject(new Error(error || output));
+        });
+    });
+}

package/dist/lib/static.js

@@ -0,0 +1,69 @@
+import fs from "node:fs";
+import path from "node:path";
+export function serveStaticFile(reqPath, webRoot) {
+    const relPath = reqPath === "/" ? "/index.html" : reqPath;
+    const safePath = safeJoin(webRoot, relPath);
+    if (!safePath)
+        return new Response("Not Found", { status: 404 });
+    const fileContent = readFileOrNull(safePath);
+    if (fileContent) {
+        return new Response(toArrayBuffer(fileContent), {
+            headers: { "content-type": contentType(path.extname(safePath)) }
+        });
+    }
+    if (relPath !== "/index.html") {
+        const indexPath = path.join(webRoot, "index.html");
+        const indexContent = readFileOrNull(indexPath);
+        if (indexContent) {
+            return new Response(toArrayBuffer(indexContent), {
+                headers: { "content-type": "text/html; charset=utf-8" }
+            });
+        }
+    }
+    return new Response("Not Found", { status: 404 });
+}
+function readFileOrNull(filePath) {
+    try {
+        return fs.readFileSync(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+function toArrayBuffer(data) {
+    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+}
+function safeJoin(root, reqPath) {
+    const normalized = path.normalize(reqPath).replace(/^(\.\.(\/|\\|$))+/, "");
+    const resolved = path.join(root, normalized);
+    if (!resolved.startsWith(root))
+        return null;
+    return resolved;
+}
+function contentType(ext) {
+    switch (ext) {
+        case ".html":
+            return "text/html; charset=utf-8";
+        case ".css":
+            return "text/css; charset=utf-8";
+        case ".js":
+            return "text/javascript; charset=utf-8";
+        case ".map":
+            return "application/json; charset=utf-8";
+        case ".svg":
+            return "image/svg+xml";
+        case ".png":
+            return "image/png";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".ico":
+            return "image/x-icon";
+        case ".woff":
+            return "font/woff";
+        case ".woff2":
+            return "font/woff2";
+        default:
+            return "application/octet-stream";
+    }
+}

package/dist/lib/system.js

@@ -0,0 +1,31 @@
+import { REQUIRED_NODE_MAJOR } from "./constants.js";
+import { findOnPath } from "./runner.js";
+export async function getSystemStatus() {
+    const major = parseMajor(process.version);
+    return {
+        node: {
+            current: process.version,
+            required: `>=${REQUIRED_NODE_MAJOR}`,
+            ok: major >= REQUIRED_NODE_MAJOR
+        },
+        platform: process.platform,
+        arch: process.arch
+    };
+}
+export async function getCliStatus(runCommand) {
+    const pathMatch = findOnPath("clawdbot");
+    if (!pathMatch) {
+        return { installed: false, path: null, version: null };
+    }
+    const version = await runCommand(pathMatch, ["--version"], 2000).catch(() => null);
+    return {
+        installed: true,
+        path: pathMatch,
+        version: version?.trim() ?? null
+    };
+}
+function parseMajor(version) {
+    const cleaned = version.replace(/^v/, "");
+    const [major] = cleaned.split(".");
+    return Number(major);
+}