@moor-sh/cli 0.1.0

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@moor-sh/cli",
+  "version": "0.1.0",
+  "description": "Command-line interface for moor - manage your moor server's projects, logs, env vars, and container lifecycle.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/caiopizzol/moor.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/caiopizzol/moor#cli",
+  "bugs": "https://github.com/caiopizzol/moor/issues",
+  "keywords": [
+    "moor",
+    "cli",
+    "docker"
+  ],
+  "type": "module",
+  "bin": {
+    "moor": "src/index.ts"
+  },
+  "files": [
+    "src/"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "bun build src/index.ts --compile --outfile moor"
+  }
+}

package/src/client.ts

@@ -0,0 +1,106 @@
+function getConfig(): { baseUrl: string; apiKey: string } {
+  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 };
+}
+
+function headers(apiKey: string, json = false): Record<string, string> {
+  const h: Record<string, string> = { Authorization: `Bearer ${apiKey}` };
+  if (json) h["Content-Type"] = "application/json";
+  return h;
+}
+
+export async function apiGet(path: string): Promise<Response> {
+  const { baseUrl, apiKey } = getConfig();
+  return fetch(`${baseUrl}${path}`, { headers: headers(apiKey) });
+}
+
+export async function apiPost(path: string, body?: unknown): Promise<Response> {
+  const { baseUrl, apiKey } = getConfig();
+  return fetch(`${baseUrl}${path}`, {
+    method: "POST",
+    headers: headers(apiKey, body !== undefined),
+    body: body !== undefined ? JSON.stringify(body) : undefined,
+  });
+}
+
+export async function apiPut(path: string, body: unknown): Promise<Response> {
+  const { baseUrl, apiKey } = getConfig();
+  return fetch(`${baseUrl}${path}`, {
+    method: "PUT",
+    headers: headers(apiKey, true),
+    body: JSON.stringify(body),
+  });
+}
+
+type Project = {
+  id: number;
+  name: string;
+  status: string;
+  container_id: string | null;
+  image_tag: string | null;
+  domain: string | null;
+  docker_image: string | null;
+  github_url: string | null;
+};
+
+export async function resolveProject(nameOrId: string): Promise<Project> {
+  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()) as Project[];
+  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;
+}
+
+export async function streamSSE(
+  res: Response,
+  handlers: {
+    onLog?: (text: string) => void;
+    onError?: (text: string) => void;
+    onDone?: (text: string) => void;
+  },
+): Promise<void> {
+  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("\n");
+    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 = "";
+      }
+      // Ignore keepalive comments starting with ":"
+    }
+  }
+}

package/src/commands/env.ts

@@ -0,0 +1,97 @@
+import { apiGet, apiPost, apiPut, resolveProject } from "../client";
+
+type EnvVar = { key: string; value: string };
+
+export async function envCommand(args: string[]) {
+  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: string[]) {
+  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 res.text()}`);
+    process.exit(1);
+  }
+
+  const vars = (await res.json()) as EnvVar[];
+  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: string[]) {
+  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);
+  }
+
+  // Parse K=V pairs
+  const newVars: EnvVar[] = [];
+  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);
+
+  // Fetch existing env vars and merge
+  const existingRes = await apiGet(`/api/projects/${project.id}/envs`);
+  if (!existingRes.ok) {
+    console.error(`Failed to get env vars: ${await existingRes.text()}`);
+    process.exit(1);
+  }
+  const existing = (await existingRes.json()) as EnvVar[];
+
+  // Merge: new values overwrite existing keys
+  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 setRes.text()}`);
+    process.exit(1);
+  }
+
+  for (const v of newVars) {
+    console.log(`Set ${v.key}`);
+  }
+
+  // Restart if container is running
+  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 startRes.text()}`);
+      process.exit(1);
+    }
+    console.log(`${project.name} restarted.`);
+  }
+}

package/src/commands/exec.ts

@@ -0,0 +1,29 @@
+import { apiPost, resolveProject } from "../client";
+
+export async function execCommand(args: string[]) {
+  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 res.text()}`);
+    process.exit(1);
+  }
+
+  const result = (await res.json()) as {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+  };
+
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  process.exit(result.exitCode);
+}

package/src/commands/logs.ts

@@ -0,0 +1,62 @@
+import { apiGet, resolveProject } from "../client";
+
+export async function logsCommand(args: string[]) {
+  let follow = false;
+  let tail = 100;
+  let projectName: string | undefined;
+
+  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);
+
+  // Initial fetch with tail
+  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()) as { logs: string; lastTimestamp: number };
+  if (data.logs) process.stdout.write(data.logs);
+
+  if (!follow) return;
+
+  // Poll for new logs
+  let since = data.lastTimestamp;
+  const poll = async () => {
+    try {
+      const res = await apiGet(`/api/projects/${project.id}/logs?since=${since}`);
+      if (!res.ok) return;
+      const data = (await res.json()) as { logs: string; lastTimestamp: number };
+      if (data.logs?.trim()) {
+        process.stdout.write(data.logs);
+        since = data.lastTimestamp;
+      }
+    } catch {
+      // Connection error, keep polling
+    }
+  };
+
+  const interval = setInterval(poll, 2000);
+
+  process.on("SIGINT", () => {
+    clearInterval(interval);
+    process.exit(0);
+  });
+
+  // Keep the process alive
+  await new Promise(() => {});
+}

package/src/commands/rebuild.ts

@@ -0,0 +1,40 @@
+import { apiPost, resolveProject, streamSSE } from "../client";
+
+export async function rebuildCommand(args: string[]) {
+  let noCache = false;
+  let projectName: string | undefined;
+
+  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 res.text();
+    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}\n`);
+      failed = true;
+    },
+    onDone: (text) => console.log(text),
+  });
+
+  process.exit(failed ? 1 : 0);
+}

package/src/commands/restart.ts

@@ -0,0 +1,27 @@
+import { apiPost, resolveProject } from "../client";
+
+export async function restartCommand(args: string[]) {
+  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 stopRes.text()}`);
+    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 startRes.text()}`);
+    process.exit(1);
+  }
+
+  console.log(`${project.name} restarted.`);
+}

package/src/commands/stats.ts

@@ -0,0 +1,29 @@
+import { apiGet } from "../client";
+
+type ServerStats = {
+  hostname: string;
+  os: string;
+  uptime: string;
+  cpu: { percent: number; cores: number };
+  memory: { total: string; used: string; percent: number };
+  disk: { total: string; used: string; percent: number };
+  containers: { running: number; total: number };
+};
+
+export 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()) as ServerStats;
+
+  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}%)`);
+  console.log(`Disk:        ${s.disk.used} / ${s.disk.total} (${s.disk.percent}%)`);
+  console.log(`Containers:  ${s.containers.running} running / ${s.containers.total} total`);
+}

package/src/commands/status.ts

@@ -0,0 +1,56 @@
+import { apiGet } from "../client";
+
+type Project = {
+  id: number;
+  name: string;
+  status: string;
+  image_tag: string | null;
+  domain: string | null;
+  docker_image: string | null;
+  github_url: string | null;
+};
+
+export 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()) as Project[];
+  if (projects.length === 0) {
+    console.log("No projects found.");
+    return;
+  }
+
+  // Calculate column widths
+  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("  "),
+    );
+  }
+}

package/src/index.ts

@@ -0,0 +1,80 @@
+#!/usr/bin/env bun
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { envCommand } from "./commands/env";
+import { execCommand } from "./commands/exec";
+import { logsCommand } from "./commands/logs";
+import { rebuildCommand } from "./commands/rebuild";
+import { restartCommand } from "./commands/restart";
+import { statsCommand } from "./commands/stats";
+import { statusCommand } from "./commands/status";
+
+// Read version from package.json at runtime so the binary always reports the
+// real shipped version. import.meta.dir resolves to packages/cli/src in this
+// repo and to <install-root>/src in a published install; ../package.json is
+// the package root in both cases.
+const VERSION = (
+  JSON.parse(readFileSync(join(import.meta.dir, "..", "package.json"), "utf8")) as {
+    version: string;
+  }
+).version;
+
+function printHelp() {
+  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
+
+Environment:
+  MOOR_URL      Server URL (e.g. https://moor.example.com)
+  MOOR_API_KEY  API key for authentication`);
+}
+
+const args = process.argv.slice(2);
+const 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 "--help":
+  case "-h":
+  case "help":
+    printHelp();
+    break;
+  case "--version":
+  case "-v":
+    console.log(VERSION);
+    break;
+  default:
+    if (command) console.error(`Unknown command: ${command}\n`);
+    printHelp();
+    process.exit(command ? 1 : 0);
+}