openclaw-manager 0.1.1 → 0.1.3

package/bin/commands/start.js

@@ -0,0 +1,108 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import prompts from "prompts";
+import { ensureDir, hasAdminConfig, resolveConfigPaths, writeAdminConfig } from "../lib/config.js";
+import { isPidRunning, readPid } from "../lib/pids.js";
+import { resolvePackageRoot } from "../lib/paths.js";
+export async function startManager(flags) {
+    const paths = resolveConfigPaths(flags);
+    ensureDir(paths.configDir);
+    ensureDir(path.dirname(paths.logPath));
+    ensureDir(path.dirname(paths.errorLogPath));
+    if (fs.existsSync(paths.pidPath)) {
+        const pid = readPid(paths.pidPath);
+        if (pid && isPidRunning(pid)) {
+            console.log(`[manager] Already running (pid: ${pid}).`);
+            return;
+        }
+    }
+    const explicitUser = normalizeString(flags.user ??
+        process.env.MANAGER_ADMIN_USER ??
+        process.env.OPENCLAW_MANAGER_ADMIN_USER);
+    const explicitPass = normalizeString(flags.pass ??
+        process.env.MANAGER_ADMIN_PASS ??
+        process.env.OPENCLAW_MANAGER_ADMIN_PASS);
+    if (explicitUser || explicitPass) {
+        if (!explicitUser || !explicitPass) {
+            throw new Error("[manager] Both --user and --password are required when overriding admin config.");
+        }
+        writeAdminConfig(paths.configPath, explicitUser, explicitPass);
+    }
+    else if (!hasAdminConfig(paths.configPath)) {
+        if (flags.nonInteractive || !process.stdin.isTTY) {
+            throw new Error("[manager] Admin username/password is required. Use --user/--password.");
+        }
+        const response = await prompts([
+            {
+                type: "text",
+                name: "username",
+                message: "Admin username",
+                validate: (value) => (value ? true : "Username is required")
+            },
+            {
+                type: "password",
+                name: "password",
+                message: "Admin password",
+                validate: (value) => (value ? true : "Password is required")
+            }
+        ], {
+            onCancel: () => {
+                throw new Error("[manager] Prompt cancelled.");
+            }
+        });
+        const username = normalizeString(response.username);
+        const password = normalizeString(response.password);
+        if (!username || !password) {
+            throw new Error("[manager] Admin username/password is required.");
+        }
+        writeAdminConfig(paths.configPath, username, password);
+    }
+    const pkgRoot = resolvePackageRoot();
+    const apiEntry = path.join(pkgRoot, "dist", "index.js");
+    const webDist = path.join(pkgRoot, "web-dist");
+    if (!fs.existsSync(apiEntry) || !fs.existsSync(webDist)) {
+        throw new Error("[manager] Package is missing build artifacts. Please reinstall or use a release that includes dist assets.");
+    }
+    const out = fs.openSync(paths.logPath, "a");
+    const err = fs.openSync(paths.errorLogPath, "a");
+    const child = spawn(process.execPath, [apiEntry], {
+        env: {
+            ...process.env,
+            MANAGER_API_HOST: paths.apiHost,
+            MANAGER_API_PORT: String(paths.apiPort),
+            MANAGER_WEB_DIST: webDist,
+            MANAGER_CONFIG_PATH: paths.configPath
+        },
+        detached: true,
+        stdio: ["ignore", out, err]
+    });
+    child.unref();
+    fs.writeFileSync(paths.pidPath, String(child.pid), "utf-8");
+    const lanIp = resolveLanIp();
+    console.log(`[manager] Started (pid: ${child.pid}).`);
+    console.log(`[manager] Log: ${paths.logPath}`);
+    console.log(`[manager] Error log: ${paths.errorLogPath}`);
+    console.log(`[manager] Open (local): http://localhost:${paths.apiPort}`);
+    console.log(`[manager] Open (local): http://127.0.0.1:${paths.apiPort}`);
+    if (lanIp) {
+        console.log(`[manager] Open (LAN): http://${lanIp}:${paths.apiPort}`);
+    }
+}
+function resolveLanIp() {
+    const nets = os.networkInterfaces();
+    for (const name of Object.keys(nets)) {
+        for (const net of nets[name] ?? []) {
+            if (net.family === "IPv4" && !net.internal) {
+                return net.address;
+            }
+        }
+    }
+    return null;
+}
+function normalizeString(value) {
+    if (typeof value !== "string")
+        return "";
+    return value.trim();
+}

package/bin/commands/stop-all.js

@@ -0,0 +1,82 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { listGatewayProcesses } from "../lib/system.js";
+import { stopManager } from "./stop.js";
+import { readPid } from "../lib/pids.js";
+export function stopAll(flags) {
+    const messages = [];
+    const errors = [];
+    const managerResult = stopManager(flags);
+    messages.push(...managerResult.messages);
+    if (!managerResult.ok && managerResult.error)
+        errors.push(managerResult.error);
+    const sandboxes = listSandboxInstances();
+    if (!sandboxes.length) {
+        messages.push("sandbox: none");
+    }
+    else {
+        for (const rootDir of sandboxes) {
+            const result = stopSandboxDir(rootDir);
+            if (result.ok) {
+                messages.push(`sandbox: ${result.message}`);
+            }
+            else {
+                errors.push(`sandbox: ${result.error ?? "stop failed"}`);
+            }
+        }
+    }
+    const gatewayPids = listGatewayProcesses();
+    if (!gatewayPids.length) {
+        messages.push("gateway: none");
+    }
+    else {
+        for (const pid of gatewayPids) {
+            try {
+                process.kill(pid, "SIGTERM");
+            }
+            catch {
+                // ignore individual failures
+            }
+        }
+        messages.push(`gateway: stopped (${gatewayPids.join(", ")})`);
+    }
+    if (errors.length) {
+        return { ok: false, messages, error: errors.join("; ") };
+    }
+    return { ok: true, messages };
+}
+function listSandboxInstances() {
+    const dir = os.tmpdir();
+    let entries = [];
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => {
+        return (entry.isDirectory() &&
+            (entry.name.startsWith("openclaw-manager-sandbox-") ||
+                entry.name.startsWith("clawdbot-manager-sandbox-")));
+    })
+        .map((entry) => path.join(dir, entry.name));
+}
+function stopSandboxDir(rootDir) {
+    const pidFile = path.join(rootDir, "manager-api.pid");
+    if (!fs.existsSync(pidFile)) {
+        return { ok: true, message: `already stopped (${rootDir})` };
+    }
+    const pid = readPid(pidFile);
+    if (!pid) {
+        return { ok: true, message: `pid invalid (${rootDir})` };
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+        return { ok: true, message: `stopped pid ${pid}` };
+    }
+    catch (err) {
+        return { ok: false, error: `failed to stop pid ${pid}: ${String(err)}` };
+    }
+}

package/bin/commands/stop.js

@@ -0,0 +1,63 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { resolveConfigDirCandidates } from "../lib/config.js";
+import { readPid } from "../lib/pids.js";
+import { commandExists, findListeningPids } from "../lib/system.js";
+export function stopManager(flags) {
+    const messages = [];
+    const errors = [];
+    let stopped = false;
+    if (process.platform !== "win32" && commandExists("systemctl")) {
+        const serviceName = "clawdbot-manager";
+        const servicePath = `/etc/systemd/system/${serviceName}.service`;
+        if (fs.existsSync(servicePath)) {
+            const result = spawnSync("systemctl", ["stop", serviceName], { encoding: "utf-8" });
+            if (result.status === 0) {
+                messages.push("manager: stopped systemd service");
+                stopped = true;
+            }
+        }
+    }
+    const candidates = resolveConfigDirCandidates(flags);
+    for (const configDir of candidates) {
+        const pidPath = path.join(configDir, "manager.pid");
+        if (!fs.existsSync(pidPath))
+            continue;
+        const pid = readPid(pidPath);
+        if (!pid)
+            continue;
+        try {
+            process.kill(pid, "SIGTERM");
+            fs.rmSync(pidPath, { force: true });
+            messages.push(`manager: stopped pid ${pid}`);
+            stopped = true;
+        }
+        catch (err) {
+            errors.push(`manager: failed to stop pid ${pid}: ${String(err)}`);
+        }
+    }
+    if (!stopped) {
+        const port = flags.apiPort ?? Number(process.env.MANAGER_API_PORT ?? 17321);
+        const pids = findListeningPids(port);
+        if (pids.length) {
+            for (const pid of pids) {
+                try {
+                    process.kill(pid, "SIGTERM");
+                }
+                catch (err) {
+                    errors.push(`manager: failed to stop pid ${pid}: ${String(err)}`);
+                }
+            }
+            messages.push(`manager: stopped port ${port} (pids: ${pids.join(", ")})`);
+            stopped = true;
+        }
+    }
+    if (!stopped && !errors.length) {
+        messages.push("manager: not running");
+    }
+    if (errors.length) {
+        return { ok: false, messages, error: errors.join("; ") };
+    }
+    return { ok: true, messages };
+}

package/bin/lib/args.js

@@ -0,0 +1,87 @@
+const longKeyMap = {
+    help: "help",
+    version: "version",
+    user: "user",
+    username: "user",
+    pass: "pass",
+    password: "pass",
+    "api-port": "apiPort",
+    "api-host": "apiHost",
+    "config-dir": "configDir",
+    "config-path": "configPath",
+    "log-path": "logPath",
+    "error-log-path": "errorLogPath",
+    "non-interactive": "nonInteractive"
+};
+const shortKeyMap = {
+    h: "help",
+    v: "version",
+    u: "user",
+    p: "pass"
+};
+export function parseArgs(argv) {
+    const flags = {};
+    const positionals = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--") {
+            positionals.push(...argv.slice(i + 1));
+            break;
+        }
+        if (arg.startsWith("--")) {
+            const [rawKey, inlineValue] = arg.slice(2).split("=");
+            const key = longKeyMap[rawKey] ?? rawKey;
+            if (key === "help" || key === "version" || key === "nonInteractive") {
+                flags[key] = true;
+            }
+            else if (inlineValue !== undefined) {
+                setFlag(flags, key, inlineValue);
+            }
+            else if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+                setFlag(flags, key, argv[i + 1]);
+                i += 1;
+            }
+            else {
+                flags[key] = true;
+            }
+            continue;
+        }
+        if (arg.startsWith("-") && arg.length > 1) {
+            const shorts = arg.slice(1).split("");
+            for (const short of shorts) {
+                const mapped = shortKeyMap[short] ?? short;
+                if (mapped === "help" || mapped === "version") {
+                    flags[mapped] = true;
+                }
+                else if (mapped === "user" || mapped === "pass") {
+                    if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+                        setFlag(flags, mapped, argv[i + 1]);
+                        i += 1;
+                    }
+                    else {
+                        flags[mapped] = true;
+                    }
+                }
+                else {
+                    flags[mapped] = true;
+                }
+            }
+            continue;
+        }
+        positionals.push(arg);
+    }
+    const command = (positionals[0] ?? "");
+    return { command, flags };
+}
+function setFlag(flags, key, value) {
+    if (key === "apiPort") {
+        const num = Number(value);
+        if (Number.isFinite(num)) {
+            flags.apiPort = num;
+            return;
+        }
+    }
+    if (key in flags || key in longKeyMap) {
+        flags[key] = value;
+    }
+}

package/bin/lib/banner.js

@@ -0,0 +1,13 @@
+import { readPackageVersion } from "./version.js";
+const BANNER_LINES = [
+    "   ____                 __      __           __  ___                                  ",
+    "  / __ \\____  ___  ____/ /___ _/ /___  _____/  |/  /___ _____  ____ _____  _____     ",
+    " / / / / __ \\/ _ \\/ __  / __ `/ / __ \\___/ /|_/ / __ `/ __ \\/ __ `/ __ \\/ ___/     ",
+    "/ /_/ / /_/ /  __/ /_/ / /_/ / / / / / /__/ /  / / /_/ / / / / /_/ / /_/ / /         ",
+    "\\____/ .___/\\___/\\__,_/\\__,_/_/_/ /_/\\___/_/  /_/\\__,_/_/ /_/\\__,_/\\____/_/          ",
+    "    /_/                                                                           "
+];
+export function printBanner() {
+    const version = readPackageVersion();
+    console.log(`${BANNER_LINES.join("\n")}\nopenclaw-manager ${version}`);
+}

package/bin/lib/config.js

@@ -0,0 +1,74 @@
+import { randomBytes, scryptSync } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function resolveConfigPaths(flags) {
+    const apiPort = flags.apiPort ?? Number(process.env.MANAGER_API_PORT ?? 17321);
+    const apiHost = flags.apiHost ?? process.env.MANAGER_API_HOST ?? "0.0.0.0";
+    const envConfigDir = process.env.MANAGER_CONFIG_DIR ?? "";
+    const envConfigPath = process.env.MANAGER_CONFIG_PATH ?? "";
+    let configDir = flags.configDir ?? envConfigDir;
+    let configPath = flags.configPath ?? envConfigPath;
+    if (!configDir && configPath) {
+        configDir = path.dirname(configPath);
+    }
+    if (!configDir) {
+        configDir = path.join(os.homedir(), ".openclaw-manager");
+    }
+    if (!configPath) {
+        configPath = path.join(configDir, "config.json");
+    }
+    const logPath = flags.logPath ?? process.env.MANAGER_LOG_PATH ?? path.join(configDir, "openclaw-manager.log");
+    const errorLogPath = flags.errorLogPath ??
+        process.env.MANAGER_ERROR_LOG_PATH ??
+        path.join(configDir, "openclaw-manager.error.log");
+    return {
+        apiPort,
+        apiHost,
+        configDir,
+        configPath,
+        logPath,
+        errorLogPath,
+        pidPath: path.join(configDir, "manager.pid")
+    };
+}
+export function ensureDir(dir) {
+    if (!dir)
+        return;
+    fs.mkdirSync(dir, { recursive: true });
+}
+export function hasAdminConfig(configPath) {
+    if (!fs.existsSync(configPath))
+        return false;
+    try {
+        const raw = fs.readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return Boolean(parsed?.auth?.username &&
+            typeof parsed.auth.username === "string" &&
+            typeof parsed.auth.salt === "string" &&
+            typeof parsed.auth.hash === "string");
+    }
+    catch {
+        return false;
+    }
+}
+export function writeAdminConfig(configPath, username, password) {
+    const salt = randomBytes(16).toString("base64");
+    const hash = scryptSync(password, salt, 64).toString("base64");
+    const payload = {
+        auth: { username, salt, hash },
+        createdAt: new Date().toISOString()
+    };
+    ensureDir(path.dirname(configPath));
+    fs.writeFileSync(configPath, JSON.stringify(payload, null, 2));
+    console.log(`[manager] Admin config saved to ${configPath}`);
+}
+export function resolveConfigDirCandidates(flags) {
+    const explicit = flags.configDir ?? process.env.MANAGER_CONFIG_DIR;
+    if (explicit)
+        return [explicit];
+    return [
+        path.join(os.homedir(), ".openclaw-manager"),
+        path.join(os.homedir(), ".clawdbot-manager")
+    ];
+}

package/bin/lib/help.js

@@ -0,0 +1,9 @@
+import { printBanner } from "./banner.js";
+export function printHelp() {
+    printBanner();
+    console.log(`\nUsage:\n  openclaw-manager <command> [options]\n\nCommands:\n  start     Start OpenClaw Manager\n  stop      Stop the running Manager process\n  stop-all  Stop Manager, sandboxes, and gateway processes\n\nOptions:\n  -h, --help            Show help\n  -v, --version         Show version\n  -u, --user <name>     Admin username (start)\n  -p, --pass <value>    Admin password (start)\n  --non-interactive     Fail instead of prompting for credentials\n  --api-port <port>     API port (default: 17321)\n  --api-host <host>     API host (default: 0.0.0.0)\n  --config-dir <dir>    Config directory\n  --config-path <path>  Config file path\n`);
+}
+export function printWelcome() {
+    printBanner();
+    console.log(`\nQuick start:\n  openclaw-manager start\n\nCommon commands:\n  openclaw-manager stop\n  openclaw-manager stop-all\n\nTip: First start will ask for admin username/password.\nDocs: https://openclaw-manager.com\n`);
+}

package/bin/lib/paths.js

@@ -0,0 +1,6 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export function resolvePackageRoot() {
+    const filePath = fileURLToPath(import.meta.url);
+    return path.resolve(path.dirname(filePath), "..", "..");
+}

package/bin/lib/pids.js

@@ -0,0 +1,22 @@
+import fs from "node:fs";
+export function readPid(pidPath) {
+    try {
+        const raw = fs.readFileSync(pidPath, "utf-8").trim();
+        const pid = Number(raw);
+        if (!Number.isFinite(pid) || pid <= 0)
+            return null;
+        return pid;
+    }
+    catch {
+        return null;
+    }
+}
+export function isPidRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/bin/lib/system.js

@@ -0,0 +1,31 @@
+import { spawnSync } from "node:child_process";
+export function commandExists(cmd) {
+    const result = spawnSync("command", ["-v", cmd], { encoding: "utf-8", shell: true });
+    return result.status === 0;
+}
+export function findListeningPids(port) {
+    if (process.platform === "win32" || !commandExists("lsof"))
+        return [];
+    const result = spawnSync("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], {
+        encoding: "utf-8"
+    });
+    if (result.error || result.status !== 0)
+        return [];
+    return String(result.stdout)
+        .split(/\s+/)
+        .map((value) => Number(value.trim()))
+        .filter((pid) => Number.isFinite(pid) && pid > 0);
+}
+export function listGatewayProcesses() {
+    if (process.platform === "win32" || !commandExists("pgrep"))
+        return [];
+    const result = spawnSync("pgrep", ["-fl", "clawdbot-gateway"], { encoding: "utf-8" });
+    if (result.error || result.status !== 0)
+        return [];
+    return String(result.stdout)
+        .split(/\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => Number(line.split(/\s+/)[0]))
+        .filter((pid) => Number.isFinite(pid) && pid > 0);
+}

package/bin/lib/types.js

@@ -0,0 +1 @@
+export {};

package/bin/lib/version.js

@@ -0,0 +1,17 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolvePackageRoot } from "./paths.js";
+export function readPackageVersion() {
+    try {
+        const pkgRoot = resolvePackageRoot();
+        const pkgPath = path.join(pkgRoot, "package.json");
+        const raw = fs.readFileSync(pkgPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.version && typeof parsed.version === "string")
+            return parsed.version;
+    }
+    catch {
+        // ignore
+    }
+    return "0.0.0";
+}