@maker-or/opencms 0.1.0

package/README.md

@@ -0,0 +1,22 @@
+# OpenCMS CLI
+
+The developer-first CLI for creating and connecting Next.js applications to OpenCMS.
+
+## Requirements
+
+- Node.js 20 or newer
+- Git
+
+## Usage
+
+```bash
+npx @maker-or/opencms create
+npx @maker-or/opencms login
+npx @maker-or/opencms logout
+npx @maker-or/opencms dev
+npx @maker-or/opencms deploy
+```
+
+`opencms create` authenticates you, creates an OpenCMS project, pulls the Next.js template, writes the project configuration, and installs dependencies.
+
+The CLI stores its local login configuration in `~/.config/opencms/config.json` (or `$XDG_CONFIG_HOME/opencms/config.json` when configured).

package/dist/index.js

@@ -0,0 +1,366 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { createServer } from "node:http";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { access, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { spawn } from "node:child_process";
+import process from "node:process";
+
+// ../../packages/sdk/src/index.ts
+class OpenCmsApiError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "OpenCmsApiError";
+  }
+}
+function createSdk(options = {}) {
+  const baseUrl = (options.baseUrl ?? "http://localhost:3000").replace(/\/$/, "");
+  const fetcher = options.fetch ?? globalThis.fetch;
+  const projectId = options.projectId;
+  const environment = options.environment ?? "development";
+  async function request(path, init) {
+    const headers = new Headers(init?.headers);
+    headers.set("Accept", "application/json");
+    const token = await options.getToken?.();
+    if (token) {
+      headers.set("Authorization", `Bearer ${token}`);
+    }
+    const response = await fetcher(`${baseUrl}${path}`, {
+      ...init,
+      headers
+    });
+    if (!response.ok) {
+      let message = response.statusText || "OpenCMS API request failed";
+      try {
+        const body = await response.json();
+        message = body.error ?? message;
+      } catch {}
+      throw new OpenCmsApiError(message, response.status);
+    }
+    return await response.json();
+  }
+  return {
+    health: () => request("/api/health"),
+    projects: {
+      list: () => request("/api/projects"),
+      create: (input) => request("/api/projects", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(input)
+      })
+    },
+    pages: {
+      list: () => {
+        if (!projectId)
+          throw new Error("projectId is required to list pages");
+        return request(`/api/projects/${projectId}/pages?environment=${environment}`);
+      },
+      create: (input) => {
+        if (!projectId)
+          throw new Error("projectId is required to create pages");
+        return request(`/api/projects/${projectId}/pages`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ ...input, environment })
+        });
+      }
+    },
+    deploy: (targetProjectId = projectId) => {
+      if (!targetProjectId)
+        throw new Error("projectId is required to deploy");
+      return request(`/api/projects/${targetProjectId}/deploy`, {
+        method: "POST"
+      });
+    },
+    documents: {
+      list: () => {
+        if (!projectId)
+          throw new Error("projectId is required to list documents");
+        return request(`/api/projects/${projectId}/pages?environment=${environment}`);
+      },
+      create: (input) => request(`/api/projects/${projectId ?? ""}/pages`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ...input, environment })
+      })
+    }
+  };
+}
+
+// src/index.ts
+var dashboardUrl = process.env.OPENCMS_DASHBOARD_URL ?? "http://localhost:3000";
+var apiUrl = process.env.OPENCMS_API_URL ?? "http://localhost:3000";
+var configRoot = process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
+var configPath = join(configRoot, "opencms", "config.json");
+async function readConfig() {
+  if (!await fileExists(configPath))
+    return {};
+  try {
+    return JSON.parse(await readFile(configPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function writeConfig(config) {
+  await mkdir(join(configRoot, "opencms"), { recursive: true });
+  await writeFile(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+function tokenFor(config) {
+  return process.env.OPENCMS_CLERK_TOKEN ?? config.token ?? null;
+}
+function sdk(config, projectId) {
+  return createSdk({
+    baseUrl: process.env.OPENCMS_API_URL ?? config.apiUrl ?? apiUrl,
+    projectId,
+    getToken: () => tokenFor(config)
+  });
+}
+function fileExists(path) {
+  return access(path, constants.F_OK).then(() => true, () => false);
+}
+function runCommand(command, args, options = {}) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env ?? process.env,
+      stdio: options.inherit ? "inherit" : "ignore"
+    });
+    child.once("error", reject);
+    child.once("exit", (code) => resolve2(code ?? 1));
+  });
+}
+async function openBrowser(url) {
+  const command = process.platform === "darwin" ? ["open", url] : process.platform === "win32" ? ["cmd", "/c", "start", "", url] : ["xdg-open", url];
+  await runCommand(command[0], command.slice(1));
+}
+async function browserLogin() {
+  let resolveToken = () => {
+    return;
+  };
+  let rejectLogin = () => {
+    return;
+  };
+  const tokenPromise = new Promise((resolve2, reject) => {
+    resolveToken = resolve2;
+    rejectLogin = reject;
+  });
+  const server = createServer((request, response) => {
+    const url = new URL(request.url ?? "/", `http://${request.headers.host ?? "127.0.0.1"}`);
+    if (url.pathname !== "/callback") {
+      response.writeHead(200, { "Content-Type": "text/plain" });
+      response.end("Waiting for opencms login.");
+      return;
+    }
+    const token = url.searchParams.get("token");
+    if (!token) {
+      response.writeHead(400, { "Content-Type": "text/plain" });
+      response.end("Missing login token.");
+      return;
+    }
+    resolveToken(token);
+    response.writeHead(200, { "Content-Type": "text/html" });
+    response.end("<h1>OpenCMS login complete</h1><p>You can close this window.</p>");
+  });
+  await new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => resolve2());
+  });
+  const address = server.address();
+  if (!address || typeof address === "string")
+    throw new Error("Unable to start the login callback server.");
+  const callback = `http://127.0.0.1:${address.port}/callback`;
+  const loginUrl = `${dashboardUrl.replace(/\/$/, "")}/cli/login?redirect_uri=${encodeURIComponent(callback)}`;
+  console.log(`Opening ${loginUrl}`);
+  try {
+    await openBrowser(loginUrl);
+  } catch {
+    console.log("Open the URL above in a browser to continue.");
+  }
+  const timeout = setTimeout(() => rejectLogin(new Error("Login timed out.")), 5 * 60 * 1000);
+  try {
+    return await tokenPromise;
+  } finally {
+    clearTimeout(timeout);
+    await new Promise((resolve2) => server.close(() => resolve2()));
+  }
+}
+async function ensureToken(config) {
+  const token = tokenFor(config);
+  if (token)
+    return token;
+  const loggedInToken = await browserLogin();
+  await writeConfig({ ...config, token: loggedInToken, apiUrl: config.apiUrl ?? apiUrl });
+  return loggedInToken;
+}
+async function login() {
+  const config = await readConfig();
+  if (process.env.OPENCMS_CLERK_TOKEN) {
+    await writeConfig({ ...config, token: process.env.OPENCMS_CLERK_TOKEN, apiUrl: config.apiUrl ?? apiUrl });
+    console.log("Saved OPENCMS_CLERK_TOKEN for local CLI use.");
+    return;
+  }
+  await ensureToken(config);
+  console.log("Logged in to OpenCMS.");
+}
+async function logout() {
+  const config = await readConfig();
+  const { token: _token, ...withoutToken } = config;
+  await writeConfig(withoutToken);
+  console.log("Logged out of OpenCMS.");
+}
+function slugify(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "project";
+}
+async function writeProjectEnv(destination, project, baseUrl) {
+  const envPath = join(destination, ".env.local");
+  const existing = await fileExists(envPath) ? await readFile(envPath, "utf8") : "";
+  const managedKeys = ["NEXT_PUBLIC_OPENCMS_PROJECT_ID", "OPENCMS_API_URL", "OPENCMS_ENVIRONMENT"];
+  const kept = existing.split(`
+`).filter((line) => !managedKeys.some((key) => line.startsWith(`${key}=`))).join(`
+`).trim();
+  const managed = [
+    `NEXT_PUBLIC_OPENCMS_PROJECT_ID=${project.id}`,
+    `OPENCMS_API_URL=${baseUrl}`,
+    "OPENCMS_ENVIRONMENT=development"
+  ].join(`
+`);
+  await writeFile(envPath, `${kept ? `${kept}
+
+` : ""}${managed}
+`, "utf8");
+}
+async function ensureCmsDirectory(destination, project, baseUrl) {
+  const cmsDirectory = join(destination, "cms");
+  await mkdir(cmsDirectory, { recursive: true });
+  const configFile = join(cmsDirectory, "opencms.ts");
+  if (!await fileExists(configFile)) {
+    await writeFile(configFile, `export const opencms = {
+  projectId: process.env.NEXT_PUBLIC_OPENCMS_PROJECT_ID ?? "${project.id}",
+  apiUrl: process.env.OPENCMS_API_URL ?? "${baseUrl}",
+  environment: process.env.OPENCMS_ENVIRONMENT ?? "development",
+} as const;
+`, "utf8");
+  }
+}
+async function packageManager(destination) {
+  const files = new Set(await readdir(destination));
+  if (files.has("pnpm-lock.yaml"))
+    return ["pnpm", "install"];
+  if (files.has("yarn.lock"))
+    return ["yarn", "install"];
+  if (files.has("package-lock.json"))
+    return ["npm", "install"];
+  return ["bun", "install"];
+}
+async function installDependencies(destination) {
+  if (process.env.OPENCMS_SKIP_INSTALL === "1")
+    return;
+  const manager = await packageManager(destination);
+  console.log(`Installing dependencies with ${manager[0]}…`);
+  if (await runCommand(manager[0], manager.slice(1), { cwd: destination, inherit: true }) !== 0) {
+    throw new Error("Dependency installation failed.");
+  }
+}
+async function pullTemplate(destination) {
+  const repository = process.env.OPENCMS_TEMPLATE_REPO ?? "https://github.com/opencms/template-nextjs.git";
+  if (await fileExists(destination))
+    throw new Error(`Destination already exists: ${destination}`);
+  console.log("Pulling the OpenCMS Next.js template…");
+  if (await runCommand("git", ["clone", "--depth", "1", repository, destination], { inherit: true }) !== 0) {
+    throw new Error("Unable to pull the Next.js template.");
+  }
+  await rm(join(destination, ".git"), { recursive: true, force: true });
+}
+async function createProject() {
+  const config = await readConfig();
+  await ensureToken(config);
+  const name = prompt("Project name:")?.trim();
+  if (!name)
+    throw new Error("A project name is required.");
+  const client = sdk(await readConfig());
+  const project = await client.projects.create({ name });
+  const destination = resolve(process.cwd(), slugify(project.name));
+  await pullTemplate(destination);
+  const baseUrl = process.env.OPENCMS_API_URL ?? config.apiUrl ?? apiUrl;
+  await writeProjectEnv(destination, project, baseUrl);
+  await ensureCmsDirectory(destination, project, baseUrl);
+  await installDependencies(destination);
+  await writeConfig({ ...await readConfig(), projectId: project.id, apiUrl: baseUrl });
+  console.log(`
+Created ${project.name}.`);
+  console.log(`Project ID: ${project.id}`);
+  console.log(`Dashboard: ${dashboardUrl.replace(/\/$/, "")}/dashboard/${project.id}`);
+  console.log(`
+Next steps:
+  cd ${slugify(project.name)}
+  npx @maker-or/opencms dev
+  npx @maker-or/opencms deploy`);
+}
+async function runDev() {
+  const config = await readConfig();
+  await ensureToken(config);
+  const manager = await packageManager(process.cwd());
+  const command = manager[0] === "npm" ? ["npm", "run", "dev"] : manager[0] === "pnpm" ? ["pnpm", "dev"] : manager[0] === "yarn" ? ["yarn", "dev"] : ["bun", "run", "dev"];
+  process.exit(await runCommand(command[0], command.slice(1), { cwd: process.cwd(), env: { ...process.env, OPENCMS_ENVIRONMENT: "development" }, inherit: true }));
+}
+function projectIdFromEnv() {
+  const envPath = join(process.cwd(), ".env.local");
+  return fileExists(envPath).then(async (exists) => {
+    if (!exists)
+      return;
+    const match = (await readFile(envPath, "utf8")).match(/^NEXT_PUBLIC_OPENCMS_PROJECT_ID=(.+)$/m);
+    return match?.[1]?.trim();
+  });
+}
+async function deploy() {
+  const config = await readConfig();
+  await ensureToken(config);
+  const projectId = await projectIdFromEnv() ?? config.projectId;
+  if (!projectId)
+    throw new Error("No OpenCMS project is configured in this directory.");
+  const deployment = await sdk(await readConfig()).deploy(projectId);
+  console.log(`Deployed ${deployment.sourceEnvironment} content to ${deployment.targetEnvironment}.`);
+  if (process.env.VERCEL_TOKEN) {
+    console.log("Deploying the application to Vercel…");
+    if (await runCommand("npx", ["vercel", "--prod", "--yes", "--token", process.env.VERCEL_TOKEN], { cwd: process.cwd(), inherit: true }) !== 0) {
+      throw new Error("Vercel deployment failed.");
+    }
+  }
+}
+function printHelp() {
+  console.log(`OpenCMS CLI
+
+Usage: npx @maker-or/opencms <command>
+
+Commands:
+  create   Create a project and connected Next.js app
+  login    Authenticate this machine
+  logout   Remove local credentials
+  dev      Run the local Next.js app against development
+  deploy   Promote development content to production`);
+}
+var command = process.argv[2];
+try {
+  if (command === "create")
+    await createProject();
+  else if (command === "login")
+    await login();
+  else if (command === "logout")
+    await logout();
+  else if (command === "dev")
+    await runDev();
+  else if (command === "deploy")
+    await deploy();
+  else
+    printHelp();
+} catch (error) {
+  console.error(`
+OpenCMS: ${error instanceof Error ? error.message : String(error)}`);
+  process.exitCode = 1;
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@maker-or/opencms",
+  "version": "0.1.0",
+  "description": "The developer-first CLI for OpenCMS",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/maker-or/openCMS.git",
+    "directory": "apps/cli"
+  },
+  "homepage": "https://github.com/maker-or/openCMS",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "opencms",
+    "cms",
+    "nextjs",
+    "cli"
+  ],
+  "bin": {
+    "opencms": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts --outfile dist/index.js --target=node --format=esm",
+    "dev": "bun --watch src/index.ts",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "prepack": "bun run build"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "typescript": "^5.8.3"
+  }
+}