openclaw-manager 0.1.1

package/bin/openclaw-manager.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+import { randomBytes, scryptSync } from "node:crypto";
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import readline from "node:readline";
+import { fileURLToPath } from "node:url";
+
+const args = process.argv.slice(2);
+const cmd = args.find((arg) => !arg.startsWith("-")) ?? "start";
+
+if (args.includes("-h") || args.includes("--help") || cmd === "help") {
+  printHelp();
+  process.exit(0);
+}
+
+if (args.includes("-v") || args.includes("--version")) {
+  console.log("openclaw-manager 0.1.0");
+  process.exit(0);
+}
+
+if (cmd !== "start") {
+  console.error(`[manager] Unknown command: ${cmd}`);
+  printHelp();
+  process.exit(1);
+}
+
+void start();
+
+async function start() {
+  const apiPort = process.env.MANAGER_API_PORT ?? "17321";
+  const apiHost = process.env.MANAGER_API_HOST ?? "0.0.0.0";
+  const configDir = process.env.MANAGER_CONFIG_DIR ?? path.join(os.homedir(), ".openclaw-manager");
+  const configPath =
+    process.env.MANAGER_CONFIG_PATH ?? path.join(configDir, "config.json");
+  const logPath =
+    process.env.MANAGER_LOG_PATH ?? path.join(configDir, "openclaw-manager.log");
+  const errorLogPath =
+    process.env.MANAGER_ERROR_LOG_PATH ??
+    path.join(configDir, "openclaw-manager.error.log");
+  const pidPath = path.join(configDir, "manager.pid");
+
+  ensureDir(configDir);
+  ensureDir(path.dirname(logPath));
+  ensureDir(path.dirname(errorLogPath));
+
+  if (isRunning(pidPath)) {
+    const pid = fs.readFileSync(pidPath, "utf-8").trim();
+    console.log(`[manager] Already running (pid: ${pid}).`);
+    return;
+  }
+
+  if (!fs.existsSync(configPath)) {
+    const username =
+      process.env.MANAGER_ADMIN_USER ??
+      process.env.OPENCLAW_MANAGER_ADMIN_USER ??
+      (await promptLine("Admin username: "));
+    const password =
+      process.env.MANAGER_ADMIN_PASS ??
+      process.env.OPENCLAW_MANAGER_ADMIN_PASS ??
+      (await promptSecret("Admin password: "));
+    if (!username || !password) {
+      console.error("[manager] Admin username/password is required.");
+      process.exit(1);
+    }
+    writeAdminConfig(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)) {
+    console.error("[manager] Package is missing build artifacts.");
+    console.error("[manager] Please reinstall or use a release that includes dist assets.");
+    process.exit(1);
+  }
+
+  const out = fs.openSync(logPath, "a");
+  const err = fs.openSync(errorLogPath, "a");
+  const child = spawn(process.execPath, [apiEntry], {
+    env: {
+      ...process.env,
+      MANAGER_API_HOST: apiHost,
+      MANAGER_API_PORT: apiPort,
+      MANAGER_WEB_DIST: webDist,
+      MANAGER_CONFIG_PATH: configPath
+    },
+    detached: true,
+    stdio: ["ignore", out, err]
+  });
+  child.unref();
+
+  fs.writeFileSync(pidPath, String(child.pid), "utf-8");
+
+  const lanIp = resolveLanIp();
+  console.log(`[manager] Started (pid: ${child.pid}).`);
+  console.log(`[manager] Log: ${logPath}`);
+  console.log(`[manager] Error log: ${errorLogPath}`);
+  console.log(`[manager] Open (local): http://localhost:${apiPort}`);
+  console.log(`[manager] Open (local): http://127.0.0.1:${apiPort}`);
+  if (lanIp) {
+    console.log(`[manager] Open (LAN): http://${lanIp}:${apiPort}`);
+  }
+}
+
+function ensureDir(dir) {
+  if (!dir) return;
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function isRunning(pidPath) {
+  if (!fs.existsSync(pidPath)) return false;
+  const raw = fs.readFileSync(pidPath, "utf-8").trim();
+  const pid = Number(raw);
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+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}`);
+}
+
+async function promptLine(prompt) {
+  if (!process.stdin.isTTY) return "";
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve) => rl.question(prompt, resolve));
+  rl.close();
+  return String(answer).trim();
+}
+
+async function promptSecret(prompt) {
+  if (!process.stdin.isTTY) return "";
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    let value = "";
+    stdout.write(prompt);
+    stdin.setRawMode(true);
+    stdin.resume();
+    const onData = (data) => {
+      const char = data.toString();
+      if (char === "\n" || char === "\r") {
+        stdout.write("\n");
+        stdin.setRawMode(false);
+        stdin.pause();
+        stdin.removeListener("data", onData);
+        resolve(value.trim());
+        return;
+      }
+      if (char === "\u0003") {
+        process.exit(1);
+      }
+      value += char;
+    };
+    stdin.on("data", onData);
+  });
+}
+
+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 resolvePackageRoot() {
+  const filePath = fileURLToPath(import.meta.url);
+  return path.resolve(path.dirname(filePath), "..");
+}
+
+function printHelp() {
+  console.log(`openclaw-manager\n\nUsage:\n  openclaw-manager start\n\nOptions:\n  -h, --help     Show help\n  -v, --version  Show version\n`);
+}

package/dist/app.js

@@ -0,0 +1,39 @@
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { serveStaticFile } from "./lib/static.js";
+import { createAuthMiddleware } from "./middlewares/auth.js";
+import { registerRoutes } from "./routes/index.js";
+const DEFAULT_CORS_ORIGINS = [
+    "http://localhost:5173",
+    "http://127.0.0.1:5173",
+    "http://localhost:5179",
+    "http://127.0.0.1:5179"
+];
+export function createApp(deps, options) {
+    const app = new Hono();
+    const allowed = new Set([...DEFAULT_CORS_ORIGINS, ...options.corsOrigins]);
+    app.use("*", cors({
+        origin: (origin) => {
+            if (!origin)
+                return "*";
+            if (allowed.has("*"))
+                return "*";
+            if (allowed.has(origin))
+                return origin;
+            return "null";
+        },
+        allowHeaders: ["Content-Type", "Authorization"]
+    }));
+    app.use("/api/*", createAuthMiddleware(deps));
+    registerRoutes(app, deps);
+    if (options.webDist) {
+        app.get("*", async (c) => {
+            const reqPath = c.req.path;
+            if (reqPath.startsWith("/api") || reqPath === "/health") {
+                return c.notFound();
+            }
+            return serveStaticFile(c.req.path, options.webDist ?? "");
+        });
+    }
+    return app;
+}

package/dist/controllers/auth.controller.js

@@ -0,0 +1,19 @@
+import { getAuthStatus, loginWithCredentials } from "../services/auth.service.js";
+export function createAuthStatusHandler(deps) {
+    return (c) => {
+        const status = getAuthStatus(deps.auth.disabled);
+        return c.json({ ok: true, ...status });
+    };
+}
+export function createAuthLoginHandler(deps) {
+    return async (c) => {
+        const body = await c.req.json().catch(() => null);
+        const username = typeof body?.username === "string" ? body.username.trim() : "";
+        const password = typeof body?.password === "string" ? body.password : "";
+        const result = loginWithCredentials(deps.auth.disabled, username, password);
+        if (result.ok) {
+            return c.json({ ok: true, disabled: result.disabled });
+        }
+        return c.json({ ok: false, error: result.error }, result.status);
+    };
+}

package/dist/controllers/cli.controller.js

@@ -0,0 +1,10 @@
+import { installCli } from "../services/cli.service.js";
+export function createCliInstallHandler(deps) {
+    return async (c) => {
+        const result = await installCli(deps.runCommand);
+        if (result.ok) {
+            return c.json(result);
+        }
+        return c.json(result, 500);
+    };
+}

package/dist/controllers/discord.controller.js

@@ -0,0 +1,21 @@
+import { approveDiscordPairing, saveDiscordToken } from "../services/discord.service.js";
+export function createDiscordTokenHandler(deps) {
+    return async (c) => {
+        const body = await c.req.json().catch(() => null);
+        const token = typeof body?.token === "string" ? body.token.trim() : "";
+        if (!token)
+            return c.json({ ok: false, error: "missing token" }, 400);
+        const result = await saveDiscordToken(deps.runCommand, token);
+        return c.json(result, result.ok ? 200 : 500);
+    };
+}
+export function createDiscordPairingHandler(deps) {
+    return async (c) => {
+        const body = await c.req.json().catch(() => null);
+        const code = typeof body?.code === "string" ? body.code.trim().toUpperCase() : "";
+        if (!code)
+            return c.json({ ok: false, error: "missing code" }, 400);
+        const result = await approveDiscordPairing(deps.runCommand, code);
+        return c.json(result, result.ok ? 200 : 500);
+    };
+}

package/dist/controllers/jobs.controller.js

@@ -0,0 +1,138 @@
+import { createCliInstallJob, createAiAuthJob, createDiscordPairingJob, createDiscordPairingWaitJob, createQuickstartJob, createResourceDownloadJob } from "../services/jobs.service.js";
+export function createCliInstallJobHandler(deps) {
+    return () => {
+        const jobId = createCliInstallJob(deps);
+        return new Response(JSON.stringify({ ok: true, jobId }), {
+            status: 200,
+            headers: { "content-type": "application/json" }
+        });
+    };
+}
+export function createQuickstartJobHandler(deps) {
+    return async (c) => {
+        const body = (await c.req.json().catch(() => ({})));
+        const jobId = createQuickstartJob(deps, body);
+        return c.json({ ok: true, jobId });
+    };
+}
+export function createDiscordPairingJobHandler(deps) {
+    return async (c) => {
+        const body = await c.req.json().catch(() => null);
+        const code = typeof body?.code === "string" ? body.code.trim().toUpperCase() : "";
+        if (!code)
+            return c.json({ ok: false, error: "missing code" }, 400);
+        const jobId = createDiscordPairingJob(deps, code);
+        return c.json({ ok: true, jobId });
+    };
+}
+export function createDiscordPairingWaitJobHandler(deps) {
+    return async (c) => {
+        const body = await c.req.json().catch(() => null);
+        const timeoutMs = body?.timeoutMs;
+        const pollMs = body?.pollMs;
+        const notify = Boolean(body?.notify);
+        const jobId = createDiscordPairingWaitJob(deps, { timeoutMs, pollMs, notify });
+        return c.json({ ok: true, jobId });
+    };
+}
+export function createResourceDownloadJobHandler(deps) {
+    return async (c) => {
+        const body = await c.req.json().catch(() => null);
+        const url = typeof body?.url === "string" ? body.url.trim() : undefined;
+        const filename = typeof body?.filename === "string" ? body.filename.trim() : undefined;
+        const jobId = createResourceDownloadJob(deps, { url, filename });
+        return c.json({ ok: true, jobId });
+    };
+}
+export function createAiAuthJobHandler(deps) {
+    return async (c) => {
+        const body = await c.req.json().catch(() => null);
+        const provider = typeof body?.provider === "string" ? body.provider.trim() : "";
+        const apiKey = typeof body?.apiKey === "string" ? body.apiKey.trim() : "";
+        if (!provider)
+            return c.json({ ok: false, error: "missing provider" }, 400);
+        if (!apiKey)
+            return c.json({ ok: false, error: "missing apiKey" }, 400);
+        const jobId = createAiAuthJob(deps, { provider, apiKey });
+        return c.json({ ok: true, jobId });
+    };
+}
+export function createJobStatusHandler(deps) {
+    return (c) => {
+        const jobId = c.req.param("id");
+        const job = deps.jobStore.getJob(jobId);
+        if (!job) {
+            return c.json({ ok: false, error: "not found" }, 404);
+        }
+        return c.json({ ok: true, job });
+    };
+}
+export function createJobStreamHandler(deps) {
+    return (c) => {
+        const jobId = c.req.param("id");
+        const job = deps.jobStore.getJob(jobId);
+        if (!job) {
+            return c.json({ ok: false, error: "not found" }, 404);
+        }
+        const encoder = new TextEncoder();
+        const stream = new ReadableStream({
+            start(controller) {
+                const send = (event, data) => {
+                    const payload = `event: ${event}\n` + `data: ${JSON.stringify(data)}\n\n`;
+                    controller.enqueue(encoder.encode(payload));
+                };
+                send("status", {
+                    status: job.status,
+                    createdAt: job.createdAt,
+                    startedAt: job.startedAt,
+                    endedAt: job.endedAt
+                });
+                for (const line of job.logs) {
+                    send("log", { message: line });
+                }
+                if (job.status === "success") {
+                    send("done", { result: job.result ?? null });
+                    controller.close();
+                    return;
+                }
+                if (job.status === "failed") {
+                    send("error", { error: job.error ?? "failed" });
+                    controller.close();
+                    return;
+                }
+                const unsubscribe = deps.jobStore.subscribe(jobId, (event) => {
+                    if (event.type === "log") {
+                        send("log", { message: event.message });
+                    }
+                    else if (event.type === "status") {
+                        send("status", { status: event.status });
+                    }
+                    else if (event.type === "done") {
+                        send("done", { result: event.result ?? null });
+                        cleanup();
+                        controller.close();
+                    }
+                    else if (event.type === "error") {
+                        send("error", { error: event.error });
+                        cleanup();
+                        controller.close();
+                    }
+                });
+                const keepAlive = setInterval(() => {
+                    controller.enqueue(encoder.encode(": keep-alive\n\n"));
+                }, 15000);
+                const cleanup = () => {
+                    clearInterval(keepAlive);
+                    unsubscribe();
+                };
+            }
+        });
+        return new Response(stream, {
+            headers: {
+                "content-type": "text/event-stream",
+                "cache-control": "no-cache",
+                connection: "keep-alive"
+            }
+        });
+    };
+}

package/dist/controllers/process.controller.js

@@ -0,0 +1,26 @@
+import { listProcesses, startProcess, stopProcess } from "../services/process.service.js";
+export function createProcessListHandler(deps) {
+    return (c) => {
+        return c.json({ ok: true, processes: listProcesses(deps) });
+    };
+}
+export function createProcessStartHandler(deps) {
+    return async (c) => {
+        const body = await c.req.json().catch(() => null);
+        const id = typeof body?.id === "string" ? body.id : null;
+        if (!id)
+            return c.json({ ok: false, error: "missing id" }, 400);
+        const result = startProcess(deps, id);
+        return c.json(result.ok ? { ok: true, process: result.process } : result, result.ok ? 200 : 400);
+    };
+}
+export function createProcessStopHandler(deps) {
+    return async (c) => {
+        const body = await c.req.json().catch(() => null);
+        const id = typeof body?.id === "string" ? body.id : null;
+        if (!id)
+            return c.json({ ok: false, error: "missing id" }, 400);
+        const result = stopProcess(deps, id);
+        return c.json(result.ok ? { ok: true, process: result.process } : result, result.ok ? 200 : 400);
+    };
+}

package/dist/controllers/quickstart.controller.js

@@ -0,0 +1,11 @@
+import { runQuickstart } from "../services/quickstart.service.js";
+export function createQuickstartHandler(deps) {
+    return async (c) => {
+        const body = (await c.req.json().catch(() => ({})));
+        const result = await runQuickstart(deps, body);
+        if (!result.ok) {
+            return c.json({ ok: false, error: result.error }, result.status);
+        }
+        return c.json(result);
+    };
+}

package/dist/controllers/status.controller.js

@@ -0,0 +1,10 @@
+import { buildStatus } from "../services/status.service.js";
+export function createStatusHandler(deps) {
+    return async (c) => {
+        const data = await buildStatus(deps, {
+            gatewayHost: c.req.query("gatewayHost") ?? undefined,
+            gatewayPort: c.req.query("gatewayPort") ?? undefined
+        });
+        return c.json(data);
+    };
+}

package/dist/deps.js

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

package/dist/dev.js

@@ -0,0 +1,156 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+const DEFAULT_API_PORT = 17321;
+const DEFAULT_WEB_URL = "http://127.0.0.1:5179";
+const repoRoot = resolveRepoRoot();
+const apiPort = Number(process.env.MANAGER_API_PORT ?? process.env.ONBOARDING_API_PORT ?? DEFAULT_API_PORT);
+const webUrl = process.env.MANAGER_WEB_URL ?? process.env.ONBOARDING_WEB_URL ?? DEFAULT_WEB_URL;
+const openBrowser = (process.env.MANAGER_OPEN_BROWSER ?? process.env.ONBOARDING_OPEN_BROWSER) !== "0";
+const apiBaseUrl = `http://127.0.0.1:${apiPort}`;
+const viteCacheDir = process.env.VITE_CACHE_DIR ?? path.join(os.tmpdir(), "clawdbot-manager-vite");
+const apiProcess = spawnWithLabel("api", "pnpm", ["--filter", "clawdbot-manager-api", "dev"], {
+    cwd: repoRoot,
+    env: {
+        ...process.env,
+        MANAGER_API_PORT: String(apiPort),
+        ONBOARDING_API_PORT: String(apiPort),
+        MANAGER_AUTH_DISABLED: process.env.MANAGER_AUTH_DISABLED ?? "1"
+    }
+});
+const webProcess = spawnWithLabel("web", "pnpm", ["--filter", "clawdbot-manager-web", "dev"], {
+    cwd: repoRoot,
+    env: {
+        ...process.env,
+        VITE_CACHE_DIR: viteCacheDir,
+        VITE_MANAGER_API_URL: apiBaseUrl,
+        VITE_ONBOARDING_API_URL: apiBaseUrl
+    }
+});
+const shutdown = () => {
+    apiProcess.kill("SIGTERM");
+    webProcess.kill("SIGTERM");
+    setTimeout(() => {
+        apiProcess.kill("SIGKILL");
+        webProcess.kill("SIGKILL");
+        process.exit(0);
+    }, 2000).unref();
+};
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+(async () => {
+    const ready = await waitForUrl(webUrl, 20_000);
+    if (!ready) {
+        console.error(`[manager] UI did not become ready at ${webUrl}`);
+        return;
+    }
+    console.log(`[manager] UI ready: ${webUrl}`);
+    if (openBrowser) {
+        await openInBrowser(webUrl);
+    }
+})();
+function spawnWithLabel(label, command, args, options) {
+    const child = spawn(command, args, {
+        cwd: options.cwd,
+        env: options.env,
+        stdio: ["inherit", "pipe", "pipe"]
+    });
+    const prefix = `[${label}] `;
+    child.stdout?.on("data", (chunk) => {
+        process.stdout.write(prefix + chunk.toString());
+    });
+    child.stderr?.on("data", (chunk) => {
+        process.stderr.write(prefix + chunk.toString());
+    });
+    child.on("exit", (code) => {
+        if (code && code !== 0) {
+            console.error(`[${label}] exited with code ${code}`);
+        }
+    });
+    return child;
+}
+async function waitForUrl(url, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            const res = await fetch(url, { method: "GET" });
+            if (res.ok)
+                return true;
+        }
+        catch {
+            // retry
+        }
+        await sleep(400);
+    }
+    return false;
+}
+async function openInBrowser(url) {
+    const platform = process.platform;
+    if (platform === "darwin") {
+        await spawnDetached("open", [url]);
+        return;
+    }
+    if (platform === "win32") {
+        await spawnDetached("cmd", ["/c", "start", "", url]);
+        return;
+    }
+    await spawnDetached("xdg-open", [url]);
+}
+async function spawnDetached(command, args) {
+    try {
+        const child = spawn(command, args, { detached: true, stdio: "ignore" });
+        child.on("error", () => { });
+        child.unref();
+    }
+    catch {
+        // ignore
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+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(), "../..");
+}
+function findRepoRoot(start) {
+    let current = start;
+    for (let i = 0; i < 6; i += 1) {
+        const candidate = path.join(current, "package.json");
+        if (exists(candidate)) {
+            try {
+                const raw = fs.readFileSync(candidate, "utf-8");
+                const parsed = JSON.parse(raw);
+                if (parsed.name === "clawdbot-manager")
+                    return current;
+            }
+            catch {
+                // ignore and continue
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+function exists(p) {
+    try {
+        return Boolean(p && fs.existsSync(p));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/index.js

@@ -0,0 +1,37 @@
+import { serve } from "@hono/node-server";
+import { createApp } from "./app.js";
+import { DEFAULT_API_HOST, DEFAULT_API_PORT } from "./lib/constants.js";
+import { resolveRepoRoot, resolveWebDist } from "./lib/config.js";
+import { buildCommandRegistry, createProcessManager } from "./lib/commands.js";
+import { createJobStore } from "./lib/jobs.js";
+import { createCommandRunner } from "./lib/runner.js";
+import { parseOrigins, parsePort } from "./lib/utils.js";
+const repoRoot = resolveRepoRoot();
+const webDist = resolveWebDist(repoRoot);
+const commandRegistry = buildCommandRegistry(repoRoot);
+const processManager = createProcessManager(commandRegistry);
+const runCommand = createCommandRunner(repoRoot);
+const jobStore = createJobStore();
+const deps = {
+    repoRoot,
+    runCommand,
+    commandRegistry,
+    processManager,
+    jobStore,
+    auth: {
+        disabled: process.env.MANAGER_AUTH_DISABLED === "1",
+        allowUnconfigured: process.env.MANAGER_AUTH_ALLOW_UNCONFIGURED === "1"
+    }
+};
+const host = process.env.MANAGER_API_HOST ?? process.env.ONBOARDING_API_HOST ?? DEFAULT_API_HOST;
+const port = parsePort(process.env.MANAGER_API_PORT ?? process.env.ONBOARDING_API_PORT) ??
+    DEFAULT_API_PORT;
+const app = createApp(deps, {
+    corsOrigins: parseOrigins(process.env.MANAGER_CORS_ORIGIN),
+    webDist
+});
+serve({
+    fetch: app.fetch,
+    hostname: host,
+    port
+});