@chrysb/alphaclaw 0.7.2-beta.1 → 0.7.2-beta.2

package/lib/server/routes/cron.js

@@ -136,6 +136,17 @@ const registerCronRoutes = ({
       res.status(400).json({ ok: false, error: error.message });
     }
   });
+  app.get("/api/cron/jobs/:id/trends", requireAuth, (req, res) => {
+    try {
+      const trends = cronService.getJobRunTrends({
+        jobId: req.params.id,
+        range: String(req.query.range || "7d"),
+      });
+      res.json({ ok: true, trends });
+    } catch (error) {
+      res.status(400).json({ ok: false, error: error.message });
+    }
+  });
 
   app.get("/api/cron/usage/bulk", requireAuth, (req, res) => {
     try {

package/lib/server/routes/nodes.js

@@ -0,0 +1,286 @@
+const path = require("path");
+const crypto = require("crypto");
+const { parseJsonObjectFromNoisyOutput } = require("../utils/json");
+const { quoteShellArg } = require("../utils/shell");
+
+const kAllowedExecHosts = new Set(["gateway", "node"]);
+const kAllowedExecSecurity = new Set(["deny", "allowlist", "full"]);
+const kAllowedExecAsk = new Set(["off", "on-miss", "always"]);
+const kSafeNodeIdPattern = /^[\w\-:.]+$/;
+
+const quoteCliArg = (value) => quoteShellArg(value, { strategy: "single" });
+
+const normalizeExecAsk = (value) => {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (normalized === "on") return "on-miss";
+  return normalized;
+};
+
+const buildDefaultExecConfig = () => ({
+  host: "gateway",
+  security: "allowlist",
+  ask: "on-miss",
+  node: "",
+});
+
+const parseNodesStatus = (stdout) => {
+  const parsed = parseJsonObjectFromNoisyOutput(stdout) || {};
+  const nodes = Array.isArray(parsed.nodes) ? parsed.nodes : [];
+  const pending = Array.isArray(parsed.pending)
+    ? parsed.pending
+    : nodes.filter((entry) => entry && entry.paired === false);
+  return { nodes, pending };
+};
+
+const readExecApprovalsFile = ({ fsModule, openclawDir }) => {
+  const filePath = path.join(openclawDir, "exec-approvals.json");
+  try {
+    const raw = fsModule.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : { version: 1 };
+  } catch {
+    return { version: 1 };
+  }
+};
+
+const writeExecApprovalsFile = ({ fsModule, openclawDir, file }) => {
+  const filePath = path.join(openclawDir, "exec-approvals.json");
+  fsModule.mkdirSync(path.dirname(filePath), { recursive: true });
+  fsModule.writeFileSync(filePath, JSON.stringify(file, null, 2) + "\n", "utf8");
+};
+
+const ensureWildcardAgent = (file) => {
+  const agents = file.agents && typeof file.agents === "object" ? file.agents : {};
+  const wildcard =
+    agents["*"] && typeof agents["*"] === "object" ? agents["*"] : {};
+  const allowlist = Array.isArray(wildcard.allowlist) ? wildcard.allowlist : [];
+  agents["*"] = { ...wildcard, allowlist };
+  return { ...file, version: 1, agents };
+};
+
+const resolveSetupUiBaseUrl = (req) => {
+  const explicit = String(
+    process.env.ALPHACLAW_SETUP_URL ||
+      process.env.ALPHACLAW_BASE_URL ||
+      process.env.RENDER_EXTERNAL_URL ||
+      process.env.URL ||
+      "",
+  )
+    .trim()
+    .replace(/\/+$/, "");
+  if (explicit) return explicit;
+
+  const railwayPublicDomain = String(process.env.RAILWAY_PUBLIC_DOMAIN || "").trim();
+  if (railwayPublicDomain) {
+    return `https://${railwayPublicDomain}`;
+  }
+
+  const railwayStaticUrl = String(process.env.RAILWAY_STATIC_URL || "")
+    .trim()
+    .replace(/\/+$/, "");
+  if (railwayStaticUrl) return railwayStaticUrl;
+
+  const forwardedProto = String(req.headers["x-forwarded-proto"] || "").trim();
+  const forwardedHost = String(req.headers["x-forwarded-host"] || "").trim();
+  if (forwardedProto && forwardedHost) {
+    return `${forwardedProto}://${forwardedHost}`;
+  }
+
+  const reqProtocol = req.protocol || "http";
+  const reqHost = req.get("host");
+  if (reqHost) {
+    return `${reqProtocol}://${reqHost}`;
+  }
+
+  return "http://localhost:3000";
+};
+
+const parseBaseUrlParts = (baseUrl) => {
+  try {
+    const parsed = new URL(baseUrl);
+    const tls = parsed.protocol === "https:";
+    const port =
+      Number(parsed.port) || (tls ? 443 : 80);
+    return {
+      baseUrl: parsed.origin,
+      host: parsed.hostname,
+      port,
+      tls,
+    };
+  } catch {
+    return {
+      baseUrl: "http://localhost:3000",
+      host: "localhost",
+      port: 3000,
+      tls: false,
+    };
+  }
+};
+
+const registerNodeRoutes = ({
+  app,
+  clawCmd,
+  openclawDir,
+  gatewayToken = "",
+  fsModule,
+}) => {
+  app.get("/api/nodes", async (_req, res) => {
+    const result = await clawCmd("nodes status --json", { quiet: true });
+    if (!result.ok) {
+      return res.status(500).json({
+        ok: false,
+        error: result.stderr || "Could not load nodes status",
+      });
+    }
+    const status = parseNodesStatus(result.stdout);
+    return res.json({ ok: true, ...status });
+  });
+
+  app.post("/api/nodes/:id/approve", async (req, res) => {
+    const nodeId = String(req.params.id || "").trim();
+    if (!nodeId || !kSafeNodeIdPattern.test(nodeId)) {
+      return res.status(400).json({ ok: false, error: "Invalid node id" });
+    }
+    const result = await clawCmd(`nodes approve ${quoteCliArg(nodeId)}`);
+    if (!result.ok) {
+      return res.status(500).json({
+        ok: false,
+        error: result.stderr || "Could not approve node",
+      });
+    }
+    return res.json({ ok: true });
+  });
+
+  app.get("/api/nodes/connect-info", async (req, res) => {
+    const baseUrl = resolveSetupUiBaseUrl(req);
+    const parsed = parseBaseUrlParts(baseUrl);
+    return res.json({
+      ok: true,
+      baseUrl: parsed.baseUrl,
+      gatewayHost: parsed.host,
+      gatewayPort: parsed.port,
+      gatewayToken: String(gatewayToken || ""),
+      tls: parsed.tls,
+    });
+  });
+
+  app.get("/api/nodes/exec-config", async (_req, res) => {
+    const result = await clawCmd("config get tools.exec --json", { quiet: true });
+    if (!result.ok) {
+      return res.json({ ok: true, config: buildDefaultExecConfig() });
+    }
+    const parsed = parseJsonObjectFromNoisyOutput(result.stdout) || {};
+    const config = buildDefaultExecConfig();
+    const host = String(parsed.host || "").trim().toLowerCase();
+    const security = String(parsed.security || "").trim().toLowerCase();
+    const ask = normalizeExecAsk(parsed.ask);
+    const node = String(parsed.node || "").trim();
+    if (kAllowedExecHosts.has(host)) config.host = host;
+    if (kAllowedExecSecurity.has(security)) config.security = security;
+    if (kAllowedExecAsk.has(ask)) config.ask = ask;
+    if (node) config.node = node;
+    return res.json({ ok: true, config });
+  });
+
+  app.post("/api/nodes/exec-config", async (req, res) => {
+    const body = req.body || {};
+    const host = String(body.host || "").trim().toLowerCase();
+    const security = String(body.security || "").trim().toLowerCase();
+    const ask = normalizeExecAsk(body.ask);
+    const node = String(body.node || "").trim();
+    if (!kAllowedExecHosts.has(host)) {
+      return res.status(400).json({ ok: false, error: "Invalid exec host" });
+    }
+    if (!kAllowedExecSecurity.has(security)) {
+      return res.status(400).json({ ok: false, error: "Invalid exec security" });
+    }
+    if (!kAllowedExecAsk.has(ask)) {
+      return res.status(400).json({ ok: false, error: "Invalid exec ask mode" });
+    }
+    if (host === "node" && !node) {
+      return res
+        .status(400)
+        .json({ ok: false, error: "Node target is required when host is node" });
+    }
+
+    const commands = [
+      `config set tools.exec.host ${quoteCliArg(host)}`,
+      `config set tools.exec.security ${quoteCliArg(security)}`,
+      `config set tools.exec.ask ${quoteCliArg(ask)}`,
+      host === "node"
+        ? `config set tools.exec.node ${quoteCliArg(node)}`
+        : "config set tools.exec.node ''",
+    ];
+
+    for (const command of commands) {
+      const result = await clawCmd(command);
+      if (!result.ok) {
+        return res.status(500).json({
+          ok: false,
+          error: result.stderr || `Could not apply exec config (${command})`,
+        });
+      }
+    }
+
+    return res.json({ ok: true, restartRequired: true });
+  });
+
+  app.get("/api/nodes/exec-approvals", (_req, res) => {
+    const approvals = ensureWildcardAgent(
+      readExecApprovalsFile({ fsModule, openclawDir }),
+    );
+    const allowlist = approvals?.agents?.["*"]?.allowlist || [];
+    return res.json({
+      ok: true,
+      file: approvals,
+      allowlist,
+    });
+  });
+
+  app.post("/api/nodes/exec-approvals/allowlist", (req, res) => {
+    const pattern = String(req.body?.pattern || "").trim();
+    if (!pattern) {
+      return res.status(400).json({ ok: false, error: "pattern is required" });
+    }
+    const approvals = ensureWildcardAgent(
+      readExecApprovalsFile({ fsModule, openclawDir }),
+    );
+    const allowlist = approvals.agents["*"].allowlist;
+    const existing = allowlist.find(
+      (entry) => String(entry?.pattern || "").trim() === pattern,
+    );
+    if (existing) {
+      return res.json({ ok: true, entry: existing, unchanged: true });
+    }
+    const entry = {
+      pattern,
+      id: crypto.randomUUID(),
+      lastUsedAt: Date.now(),
+    };
+    approvals.agents["*"].allowlist = [...allowlist, entry];
+    writeExecApprovalsFile({ fsModule, openclawDir, file: approvals });
+    return res.json({ ok: true, entry });
+  });
+
+  app.delete("/api/nodes/exec-approvals/allowlist/:id", (req, res) => {
+    const id = String(req.params.id || "").trim();
+    if (!id) {
+      return res.status(400).json({ ok: false, error: "id is required" });
+    }
+    const approvals = ensureWildcardAgent(
+      readExecApprovalsFile({ fsModule, openclawDir }),
+    );
+    const allowlist = approvals.agents["*"].allowlist;
+    const nextAllowlist = allowlist.filter((entry) => String(entry?.id || "") !== id);
+    if (nextAllowlist.length === allowlist.length) {
+      return res.status(404).json({ ok: false, error: "Allowlist entry not found" });
+    }
+    approvals.agents["*"].allowlist = nextAllowlist;
+    writeExecApprovalsFile({ fsModule, openclawDir, file: approvals });
+    return res.json({ ok: true });
+  });
+};
+
+module.exports = {
+  registerNodeRoutes,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.7.2-beta.1",
+  "version": "0.7.2-beta.2",
   "publishConfig": {
     "access": "public"
   },
@@ -31,7 +31,7 @@
   "dependencies": {
     "express": "^4.21.0",
     "http-proxy": "^1.18.1",
-    "openclaw": "2026.3.11",
+    "openclaw": "2026.3.12",
     "ws": "^8.19.0"
   },
   "devDependencies": {