@moor-sh/cli 0.5.0 → 0.6.0

package/bin/moor.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import "../dist/index.js";

package/dist/index.js

@@ -0,0 +1,701 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+
+// ../contract/src/client.ts
+class MoorApiError extends Error {
+  status;
+  body;
+  constructor(status, message, body = "") {
+    super(message);
+    this.name = "MoorApiError";
+    this.status = status;
+    this.body = body;
+  }
+}
+function createMoorApiClient(options) {
+  const baseUrl = normalizeBaseUrl(options.baseUrl);
+  const apiKey = options.apiKey;
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  async function request(method, path, body, init) {
+    const hasBody = body !== undefined;
+    const headers = new Headers(init?.headers);
+    headers.set("Authorization", `Bearer ${apiKey}`);
+    if (!headers.has("Accept"))
+      headers.set("Accept", "application/json");
+    if (hasBody && !headers.has("Content-Type"))
+      headers.set("Content-Type", "application/json");
+    const res = await fetchImpl(joinUrl(baseUrl, path), {
+      ...init,
+      method,
+      headers,
+      body: hasBody ? JSON.stringify(body) : init?.body
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new MoorApiError(res.status, parseErrorMessage(text, res.status), text);
+    }
+    if (res.status === 204)
+      return;
+    return await res.json();
+  }
+  return {
+    get: (path, init) => request("GET", path, undefined, init),
+    post: (path, body, init) => request("POST", path, body, init),
+    put: (path, body, init) => request("PUT", path, body, init),
+    delete: (path, init) => request("DELETE", path, undefined, init)
+  };
+}
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+function joinUrl(baseUrl, path) {
+  if (path.startsWith("/"))
+    return `${baseUrl}${path}`;
+  return `${baseUrl}/${path}`;
+}
+function parseErrorMessage(body, status) {
+  if (body) {
+    try {
+      const parsed = JSON.parse(body);
+      if (isJsonObject(parsed) && "error" in parsed) {
+        const error = parsed.error;
+        if (typeof error === "string")
+          return error;
+        return JSON.stringify(error);
+      }
+    } catch {
+      return body;
+    }
+    return body;
+  }
+  return `HTTP ${status}`;
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// src/client.ts
+function getConfig() {
+  const baseUrl = process.env.MOOR_URL;
+  const apiKey = process.env.MOOR_API_KEY;
+  if (!baseUrl) {
+    console.error("Error: MOOR_URL is not set");
+    process.exit(1);
+  }
+  if (!apiKey) {
+    console.error("Error: MOOR_API_KEY is not set");
+    process.exit(1);
+  }
+  return { baseUrl: baseUrl.replace(/\/$/, ""), apiKey };
+}
+async function rawResponseRequest(callClient) {
+  let rawResponse;
+  const fetchRawResponse = async (input, init) => {
+    rawResponse = await globalThis.fetch(input, init);
+    return new Response(null, { status: 204 });
+  };
+  const client2 = createMoorApiClient({
+    ...getConfig(),
+    fetch: fetchRawResponse
+  });
+  await callClient(client2);
+  if (!rawResponse)
+    throw new Error("No response received");
+  return rawResponse;
+}
+async function apiGet(path) {
+  return rawResponseRequest((client2) => client2.get(path));
+}
+async function apiPost(path, body) {
+  return rawResponseRequest((client2) => client2.post(path, body));
+}
+async function apiPut(path, body) {
+  return rawResponseRequest((client2) => client2.put(path, body));
+}
+async function readErrorMessage(res) {
+  const text = await res.text();
+  return parseErrorMessage(text, res.status);
+}
+async function resolveProject(nameOrId) {
+  const res = await apiGet("/api/projects");
+  if (!res.ok) {
+    console.error(`Failed to list projects: ${res.status}`);
+    process.exit(1);
+  }
+  const projects = await res.json();
+  const match = projects.find((p) => p.name === nameOrId || String(p.id) === nameOrId);
+  if (!match) {
+    console.error(`Project "${nameOrId}" not found`);
+    process.exit(1);
+  }
+  return match;
+}
+async function streamSSE(res, handlers) {
+  const reader = res.body?.getReader();
+  if (!reader)
+    throw new Error("No response body");
+  const decoder = new TextDecoder;
+  let buffer = "";
+  let currentEvent = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split(`
+`);
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (line.startsWith("event: ")) {
+        currentEvent = line.slice(7).trim();
+      } else if (line.startsWith("data: ")) {
+        const data = JSON.parse(line.slice(6));
+        if (currentEvent === "log")
+          handlers.onLog?.(data);
+        else if (currentEvent === "error")
+          handlers.onError?.(data);
+        else if (currentEvent === "done")
+          handlers.onDone?.(data);
+        currentEvent = "";
+      }
+    }
+  }
+}
+
+// src/commands/env.ts
+async function envCommand(args) {
+  const subcommand = args[0];
+  if (subcommand === "list")
+    return envList(args.slice(1));
+  if (subcommand === "set")
+    return envSet(args.slice(1));
+  console.error("Usage: moor env <list|set> <project> [K=V ...]");
+  process.exit(1);
+}
+async function envList(args) {
+  const projectName = args[0];
+  if (!projectName) {
+    console.error("Usage: moor env list <project>");
+    process.exit(1);
+  }
+  const project = await resolveProject(projectName);
+  const res = await apiGet(`/api/projects/${project.id}/envs`);
+  if (!res.ok) {
+    console.error(`Failed: ${await readErrorMessage(res)}`);
+    process.exit(1);
+  }
+  const vars = await res.json();
+  if (vars.length === 0) {
+    console.log("No environment variables set.");
+    return;
+  }
+  for (const v of vars) {
+    console.log(`${v.key}=${v.value}`);
+  }
+}
+async function envSet(args) {
+  const projectName = args[0];
+  const pairs = args.slice(1);
+  if (!projectName || pairs.length === 0) {
+    console.error("Usage: moor env set <project> KEY=VALUE [KEY=VALUE ...]");
+    process.exit(1);
+  }
+  const newVars = [];
+  for (const pair of pairs) {
+    const eq = pair.indexOf("=");
+    if (eq === -1) {
+      console.error(`Invalid format: "${pair}" (expected KEY=VALUE)`);
+      process.exit(1);
+    }
+    newVars.push({ key: pair.slice(0, eq), value: pair.slice(eq + 1) });
+  }
+  const project = await resolveProject(projectName);
+  const existingRes = await apiGet(`/api/projects/${project.id}/envs`);
+  if (!existingRes.ok) {
+    console.error(`Failed to get env vars: ${await readErrorMessage(existingRes)}`);
+    process.exit(1);
+  }
+  const existing = await existingRes.json();
+  const merged = new Map(existing.map((v) => [v.key, v.value]));
+  for (const v of newVars) {
+    merged.set(v.key, v.value);
+  }
+  const allVars = Array.from(merged, ([key, value]) => ({ key, value }));
+  const setRes = await apiPut(`/api/projects/${project.id}/envs`, allVars);
+  if (!setRes.ok) {
+    console.error(`Failed to set env vars: ${await readErrorMessage(setRes)}`);
+    process.exit(1);
+  }
+  for (const v of newVars) {
+    console.log(`Set ${v.key}`);
+  }
+  if (project.status === "running") {
+    console.log(`Restarting ${project.name}...`);
+    await apiPost(`/api/projects/${project.id}/stop`);
+    const startRes = await apiPost(`/api/projects/${project.id}/start`);
+    if (!startRes.ok) {
+      console.error(`Warning: failed to restart: ${await readErrorMessage(startRes)}`);
+      process.exit(1);
+    }
+    console.log(`${project.name} restarted.`);
+  }
+}
+
+// src/commands/exec.ts
+async function execCommand(args) {
+  const projectName = args[0];
+  const command = args.slice(1).join(" ");
+  if (!projectName || !command) {
+    console.error("Usage: moor exec <project> <command>");
+    process.exit(1);
+  }
+  const project = await resolveProject(projectName);
+  const res = await apiPost(`/api/projects/${project.id}/exec`, { command });
+  if (!res.ok) {
+    console.error(`Failed: ${await readErrorMessage(res)}`);
+    process.exit(1);
+  }
+  const result = await res.json();
+  if (result.stdout)
+    process.stdout.write(result.stdout);
+  if (result.stderr)
+    process.stderr.write(result.stderr);
+  process.exit(result.exitCode);
+}
+
+// src/commands/history.ts
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes <= 0)
+    return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.min(units.length - 1, Math.floor(Math.log(bytes) / Math.log(1024)));
+  const val = bytes / 1024 ** i;
+  return `${val.toFixed(val < 10 ? 1 : 0)} ${units[i]}`;
+}
+function parseHistoryArgs(args) {
+  let project;
+  let hours = 24;
+  for (let i = 0;i < args.length; i++) {
+    const a = args[i];
+    if (a === "--hours") {
+      const n = Number(args[++i]);
+      if (!Number.isFinite(n) || n <= 0)
+        return { hours, error: "--hours must be a positive number" };
+      hours = n;
+    } else if (a.startsWith("--hours=")) {
+      const n = Number(a.slice("--hours=".length));
+      if (!Number.isFinite(n) || n <= 0)
+        return { hours, error: "--hours must be a positive number" };
+      hours = n;
+    } else if (!a.startsWith("-") && project === undefined) {
+      project = a;
+    }
+  }
+  if (!project)
+    return { hours, error: "missing project" };
+  return { project, hours };
+}
+async function historyCommand(args) {
+  const parsed = parseHistoryArgs(args);
+  if (parsed.error || !parsed.project) {
+    console.error(parsed.error && parsed.error !== "missing project" ? parsed.error : "Usage: moor history <project> [--hours N]");
+    process.exit(1);
+  }
+  const project = await resolveProject(parsed.project);
+  const to = Date.now();
+  const from = to - parsed.hours * 3600000;
+  const res = await apiGet(`/api/projects/${project.id}/stats/history?from=${from}&to=${to}`);
+  if (!res.ok) {
+    console.error(`Failed to get history: ${res.status} ${await readErrorMessage(res)}`);
+    process.exit(1);
+  }
+  const h = await res.json();
+  const s = h.summary;
+  const windowH = Math.round((h.to_ms - h.from_ms) / 3600000 * 10) / 10;
+  console.log(`${project.name} \u2014 history over ~${windowH}h`);
+  if (s.has_gap) {
+    console.log("  \x1B[33m\u26A0 event gap recorded: events may be incomplete\x1B[0m");
+  }
+  console.log(`  Samples:   ${s.sample_count} total, ${s.running_sample_count} running`);
+  console.log(`  CPU:       avg ${s.cpu_percent_avg ?? "n/a"}% / max ${s.cpu_percent_max ?? "n/a"}%`);
+  console.log(`  Memory:    max ${s.mem_bytes_max !== null ? formatBytes(s.mem_bytes_max) : "n/a"}`);
+  console.log(`  Network:   in ${formatBytes(s.net_rx_bytes_total)} / out ${formatBytes(s.net_tx_bytes_total)}`);
+  const counts = Object.entries(s.event_counts);
+  if (counts.length > 0) {
+    console.log(`  Events:    ${counts.map(([a, n]) => `${a} ${n}`).join(", ")}`);
+  }
+  const recent = h.events.slice(-10);
+  if (recent.length > 0) {
+    console.log(`
+Recent events:`);
+    for (const e of recent) {
+      console.log(`  ${new Date(e.occurred_at_ms).toISOString()}  ${e.action}  (${e.source})`);
+    }
+  }
+  if (s.sample_count === 0 && h.events.length === 0) {
+    console.log("  (no stored history in this window)");
+  }
+}
+
+// src/commands/logs.ts
+async function logsCommand(args) {
+  let follow = false;
+  let tail = 100;
+  let projectName;
+  for (let i = 0;i < args.length; i++) {
+    if (args[i] === "-f" || args[i] === "--follow") {
+      follow = true;
+    } else if (args[i] === "-n" || args[i] === "--lines") {
+      tail = Number(args[++i]);
+    } else if (!projectName) {
+      projectName = args[i];
+    }
+  }
+  if (!projectName) {
+    console.error("Usage: moor logs <project> [-f] [-n <lines>]");
+    process.exit(1);
+  }
+  const project = await resolveProject(projectName);
+  const res = await apiGet(`/api/projects/${project.id}/logs?tail=${tail}`);
+  if (!res.ok) {
+    console.error(`Failed to get logs: ${res.status}`);
+    process.exit(1);
+  }
+  const data = await res.json();
+  if (data.logs)
+    process.stdout.write(data.logs);
+  if (!follow)
+    return;
+  let since = data.lastTimestamp;
+  const poll = async () => {
+    try {
+      const res2 = await apiGet(`/api/projects/${project.id}/logs?since=${since}`);
+      if (!res2.ok)
+        return;
+      const data2 = await res2.json();
+      if (data2.logs?.trim()) {
+        process.stdout.write(data2.logs);
+        since = data2.lastTimestamp;
+      }
+    } catch {}
+  };
+  const interval = setInterval(poll, 2000);
+  process.on("SIGINT", () => {
+    clearInterval(interval);
+    process.exit(0);
+  });
+  await new Promise(() => {});
+}
+
+// src/commands/mcp.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var CLIENT_ALIASES = {
+  claude: "claude",
+  "claude-code": "claude",
+  codex: "codex"
+};
+var DEFAULT_URL = "http://127.0.0.1:8080";
+var PLACEHOLDER_KEY = "<your-api-key>";
+function parseDotEnv(path) {
+  if (!existsSync(path))
+    return {};
+  const content = readFileSync(path, "utf8");
+  const env = {};
+  for (const rawLine of content.split(`
+`)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    const eq = line.indexOf("=");
+    if (eq === -1)
+      continue;
+    const key = line.slice(0, eq).trim();
+    let value = line.slice(eq + 1).trim();
+    if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    env[key] = value;
+  }
+  return env;
+}
+function resolveApiKey(flagValue) {
+  if (flagValue)
+    return flagValue;
+  if (process.env.MOOR_API_KEY)
+    return process.env.MOOR_API_KEY;
+  const dotenv = parseDotEnv(join(process.cwd(), ".env"));
+  if (dotenv.MOOR_API_KEY)
+    return dotenv.MOOR_API_KEY;
+  return PLACEHOLDER_KEY;
+}
+function configFor(client2, url, apiKey) {
+  if (client2 === "claude") {
+    return JSON.stringify({
+      mcpServers: {
+        moor: {
+          command: "bunx",
+          args: ["@moor-sh/mcp"],
+          env: { MOOR_URL: url, MOOR_API_KEY: apiKey }
+        }
+      }
+    }, null, 2);
+  }
+  return [
+    "[mcp_servers.moor]",
+    'command = "bunx"',
+    'args = ["@moor-sh/mcp"]',
+    "",
+    "[mcp_servers.moor.env]",
+    `MOOR_URL = ${JSON.stringify(url)}`,
+    `MOOR_API_KEY = ${JSON.stringify(apiKey)}`
+  ].join(`
+`);
+}
+function parseFlags(args) {
+  const flags = {};
+  for (let i = 0;i < args.length; i++) {
+    const a = args[i];
+    if (a === "--client" && i + 1 < args.length)
+      flags.client = args[++i];
+    else if (a === "--url" && i + 1 < args.length)
+      flags.url = args[++i];
+    else if (a === "--api-key" && i + 1 < args.length)
+      flags.apiKey = args[++i];
+  }
+  return flags;
+}
+function printHelp() {
+  console.log(`moor mcp config - Generate MCP client config snippet for moor
+
+Usage: moor mcp config --client <name> [--url <url>] [--api-key <key>]
+
+Required:
+  --client <name>     One of: claude, claude-code, codex
+
+Optional:
+  --url <url>         moor URL the MCP server should reach (default: ${DEFAULT_URL})
+  --api-key <key>     bearer token. Falls back to MOOR_API_KEY env, then
+                      cwd's .env, then a placeholder.
+
+Output is printed to stdout for you to paste into your client's config file:
+  Claude Code:  ~/.claude.json
+  Codex:        ~/.codex/config.toml`);
+}
+function mcpCommand(args) {
+  const subcommand = args[0];
+  if (subcommand === "--help" || subcommand === "-h" || subcommand === "help" || !subcommand) {
+    printHelp();
+    return;
+  }
+  if (subcommand !== "config") {
+    console.error(`Unknown mcp subcommand: ${subcommand}
+`);
+    printHelp();
+    process.exit(1);
+  }
+  const flags = parseFlags(args.slice(1));
+  if (!flags.client) {
+    console.error(`moor mcp config requires --client <claude|claude-code|codex>
+`);
+    printHelp();
+    process.exit(1);
+  }
+  const client2 = CLIENT_ALIASES[flags.client];
+  if (!client2) {
+    console.error(`Unknown client: ${flags.client}. Expected one of: claude, claude-code, codex`);
+    process.exit(1);
+  }
+  const url = flags.url || DEFAULT_URL;
+  const apiKey = resolveApiKey(flags.apiKey);
+  console.log(configFor(client2, url, apiKey));
+}
+
+// src/commands/rebuild.ts
+async function rebuildCommand(args) {
+  let noCache = false;
+  let projectName;
+  for (const arg of args) {
+    if (arg === "--no-cache")
+      noCache = true;
+    else if (!projectName)
+      projectName = arg;
+  }
+  if (!projectName) {
+    console.error("Usage: moor rebuild <project> [--no-cache]");
+    process.exit(1);
+  }
+  const project = await resolveProject(projectName);
+  const query = noCache ? "?nocache=true" : "";
+  console.log(`Rebuilding ${project.name}...`);
+  const res = await apiPost(`/api/projects/${project.id}/run${query}`);
+  if (!res.ok && res.headers.get("content-type")?.includes("text/event-stream") === false) {
+    const body = await readErrorMessage(res);
+    console.error(`Failed: ${body}`);
+    process.exit(1);
+  }
+  let failed = false;
+  await streamSSE(res, {
+    onLog: (text) => process.stdout.write(text),
+    onError: (text) => {
+      process.stderr.write(`Error: ${text}
+`);
+      failed = true;
+    },
+    onDone: (text) => console.log(text)
+  });
+  process.exit(failed ? 1 : 0);
+}
+
+// src/commands/restart.ts
+async function restartCommand(args) {
+  const projectName = args[0];
+  if (!projectName) {
+    console.error("Usage: moor restart <project>");
+    process.exit(1);
+  }
+  const project = await resolveProject(projectName);
+  console.log(`Stopping ${project.name}...`);
+  const stopRes = await apiPost(`/api/projects/${project.id}/stop`);
+  if (!stopRes.ok) {
+    console.error(`Failed to stop: ${await readErrorMessage(stopRes)}`);
+    process.exit(1);
+  }
+  console.log(`Starting ${project.name}...`);
+  const startRes = await apiPost(`/api/projects/${project.id}/start`);
+  if (!startRes.ok) {
+    console.error(`Failed to start: ${await readErrorMessage(startRes)}`);
+    process.exit(1);
+  }
+  console.log(`${project.name} restarted.`);
+}
+
+// src/commands/stats.ts
+async function statsCommand() {
+  const res = await apiGet("/api/server/stats");
+  if (!res.ok) {
+    console.error(`Failed to get stats: ${res.status}`);
+    process.exit(1);
+  }
+  const s = await res.json();
+  console.log(`Host:        ${s.hostname}`);
+  console.log(`OS:          ${s.os}`);
+  console.log(`Uptime:      ${s.uptime}`);
+  console.log(`CPU:         ${s.cpu.percent}% (${s.cpu.cores} cores)`);
+  console.log(`Memory:      ${s.memory.used} / ${s.memory.total} (${s.memory.percent}%)`);
+  const disks = s.disks?.length ? s.disks : [{ mount: "/", ...s.disk }];
+  disks.forEach((d, i) => {
+    const prefix = i === 0 ? "Disk:" : "     ";
+    const name = d.label ? `${d.label} (${d.mount})` : d.mount;
+    console.log(`${prefix}        ${name}  ${d.used} / ${d.total} (${d.percent}%)`);
+  });
+  console.log(`Containers:  ${s.containers.running} running / ${s.containers.total} total`);
+}
+
+// src/commands/status.ts
+async function statusCommand() {
+  const res = await apiGet("/api/projects");
+  if (!res.ok) {
+    console.error(`Failed to list projects: ${res.status}`);
+    process.exit(1);
+  }
+  const projects = await res.json();
+  if (projects.length === 0) {
+    console.log("No projects found.");
+    return;
+  }
+  const nameW = Math.max(4, ...projects.map((p) => p.name.length));
+  const statusW = Math.max(6, ...projects.map((p) => p.status.length));
+  const sourceW = Math.max(6, ...projects.map((p) => (p.docker_image || p.github_url || "-").length));
+  const domainW = Math.max(6, ...projects.map((p) => (p.domain || "-").length));
+  const header = [
+    "NAME".padEnd(nameW),
+    "STATUS".padEnd(statusW),
+    "SOURCE".padEnd(sourceW),
+    "DOMAIN".padEnd(domainW)
+  ].join("  ");
+  console.log(header);
+  console.log("-".repeat(header.length));
+  for (const p of projects) {
+    const source = p.docker_image || p.github_url || "-";
+    console.log([
+      p.name.padEnd(nameW),
+      p.status.padEnd(statusW),
+      source.padEnd(sourceW),
+      (p.domain || "-").padEnd(domainW)
+    ].join("  "));
+  }
+}
+
+// src/index.ts
+var VERSION = JSON.parse(readFileSync2(join2(import.meta.dir, "..", "package.json"), "utf8")).version;
+function printHelp2() {
+  console.log(`moor - CLI for Moor server management
+
+Usage: moor <command> [options]
+
+Commands:
+  status                          List all projects
+  logs <project> [-f] [-n <lines>] View container logs
+  rebuild <project> [--no-cache]  Rebuild and restart from source
+  restart <project>               Stop and start a container
+  exec <project> <command>        Run a command in a container
+  env list <project>              List environment variables
+  env set <project> K=V [K=V ...] Set environment variables
+  stats                           Show server resource usage
+  history <project> [--hours N]   Stored resource history + events (default 24h)
+  mcp config --client <name>      Generate MCP client config snippet
+
+Environment:
+  MOOR_URL      Server URL (e.g. https://moor.example.com)
+  MOOR_API_KEY  API key for authentication`);
+}
+var args = process.argv.slice(2);
+var command = args[0];
+switch (command) {
+  case "status":
+    await statusCommand();
+    break;
+  case "logs":
+    await logsCommand(args.slice(1));
+    break;
+  case "rebuild":
+    await rebuildCommand(args.slice(1));
+    break;
+  case "restart":
+    await restartCommand(args.slice(1));
+    break;
+  case "exec":
+    await execCommand(args.slice(1));
+    break;
+  case "env":
+    await envCommand(args.slice(1));
+    break;
+  case "stats":
+    await statsCommand();
+    break;
+  case "history":
+    await historyCommand(args.slice(1));
+    break;
+  case "mcp":
+    mcpCommand(args.slice(1));
+    break;
+  case "--help":
+  case "-h":
+  case "help":
+    printHelp2();
+    break;
+  case "--version":
+  case "-v":
+    console.log(VERSION);
+    break;
+  default:
+    if (command)
+      console.error(`Unknown command: ${command}
+`);
+    printHelp2();
+    process.exit(command ? 1 : 0);
+}