@cmssy/cli 0.10.1 → 0.12.0

package/src/dev-app/app/api/blocks/[name]/config/route.ts

@@ -0,0 +1,140 @@
+import { NextResponse } from "next/server";
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+
+const projectRoot = process.env.CMSSY_PROJECT_ROOT || process.cwd();
+const SAFE_NAME_RE = /^[a-zA-Z0-9_-]+$/;
+
+function loadBlockConfig(blockPath: string): Record<string, unknown> | null {
+  const configPath = path.join(blockPath, "config.ts");
+  if (!fs.existsSync(configPath)) return null;
+
+  try {
+    const tsxPaths = [
+      path.join(projectRoot, "node_modules", ".bin", "tsx"),
+      path.join(
+        projectRoot,
+        "node_modules",
+        "cmssy-cli",
+        "node_modules",
+        ".bin",
+        "tsx",
+      ),
+    ];
+    const tsxBinary = tsxPaths.find((p) => fs.existsSync(p)) || "npx -y tsx";
+
+    const cacheDir = path.join(projectRoot, ".cmssy", "cache");
+    fs.mkdirSync(cacheDir, { recursive: true });
+
+    const tempDir = fs.mkdtempSync(path.join(cacheDir, "block-config-"));
+    try {
+      const mockConfigPath = path.join(tempDir, "cmssy-cli-config.mjs");
+      fs.writeFileSync(
+        mockConfigPath,
+        "export const defineBlock = (config) => config;\nexport const defineTemplate = (config) => config;\nexport const field = (config) => config;",
+      );
+
+      const configContent = fs.readFileSync(configPath, "utf-8");
+      const modified = configContent.replace(
+        /from\s+['"](?:@cmssy\/cli\/config|cmssy-cli\/config)['"]/g,
+        `from '${mockConfigPath.replace(/\\\\/g, "/")}'`,
+      );
+
+      const tempPath = path.join(tempDir, "temp-block-config.ts");
+      fs.writeFileSync(tempPath, modified);
+
+      const evalCode = `import cfg from '${tempPath.replace(/\\\\/g, "/")}'; console.log(JSON.stringify(cfg.default || cfg));`;
+      const cmd = tsxBinary.includes("npx")
+        ? `${tsxBinary} --eval "${evalCode}"`
+        : `"${tsxBinary}" --eval "${evalCode}"`;
+
+      const output = execSync(cmd, {
+        encoding: "utf-8",
+        cwd: projectRoot,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+
+      const lines = output.trim().split("\n");
+      return JSON.parse(lines[lines.length - 1]);
+    } finally {
+      try {
+        fs.rmSync(tempDir, { recursive: true });
+      } catch {}
+    }
+  } catch {
+    return null;
+  }
+}
+
+export async function GET(
+  _request: Request,
+  { params }: { params: Promise<{ name: string }> },
+) {
+  const { name } = await params;
+  if (!SAFE_NAME_RE.test(name)) {
+    return NextResponse.json({ error: "Invalid name" }, { status: 400 });
+  }
+
+  let blockPath = path.join(projectRoot, "blocks", name);
+  if (!fs.existsSync(blockPath)) {
+    blockPath = path.join(projectRoot, "templates", name);
+  }
+
+  if (!fs.existsSync(blockPath)) {
+    return NextResponse.json({ error: "Block not found" }, { status: 404 });
+  }
+
+  const previewPath = path.join(blockPath, "preview.json");
+  const previewData = fs.existsSync(previewPath)
+    ? JSON.parse(fs.readFileSync(previewPath, "utf-8"))
+    : {};
+
+  const config = loadBlockConfig(blockPath);
+
+  const pagesJsonPath = path.join(blockPath, "pages.json");
+  let pagesData = fs.existsSync(pagesJsonPath)
+    ? JSON.parse(fs.readFileSync(pagesJsonPath, "utf-8"))
+    : null;
+
+  if (!pagesData && config && (config.pages || config.layoutPositions)) {
+    const layoutPositions: Record<string, any> = {};
+    if (Array.isArray(config.layoutPositions)) {
+      for (const lp of config.layoutPositions as any[]) {
+        layoutPositions[lp.position] = {
+          type: lp.type,
+          content: lp.content || {},
+        };
+      }
+    } else if (
+      config.layoutPositions &&
+      typeof config.layoutPositions === "object"
+    ) {
+      Object.assign(layoutPositions, config.layoutPositions);
+    }
+
+    const pages = ((config.pages || []) as any[]).map(
+      (page: any, index: number) => ({
+        name: page.name,
+        slug:
+          page.slug === "home" || page.slug === "/" || index === 0
+            ? "/"
+            : page.slug.startsWith("/")
+              ? page.slug
+              : "/" + page.slug,
+        blocks: page.blocks || [],
+      }),
+    );
+
+    pagesData = { layoutPositions, pages };
+  }
+
+  return NextResponse.json({
+    name,
+    schema: config?.schema || {},
+    previewData,
+    pages: config?.pages,
+    layoutPositions: config?.layoutPositions,
+    pagesData,
+  });
+}

package/src/dev-app/app/api/blocks/route.ts

@@ -0,0 +1,61 @@
+import { NextResponse } from "next/server";
+import fs from "fs";
+import path from "path";
+
+const projectRoot = process.env.CMSSY_PROJECT_ROOT || process.cwd();
+
+export async function GET() {
+  const blocks: any[] = [];
+
+  const blocksDir = path.join(projectRoot, "blocks");
+  if (fs.existsSync(blocksDir)) {
+    const dirs = fs
+      .readdirSync(blocksDir, { withFileTypes: true })
+      .filter((d) => d.isDirectory());
+
+    for (const dir of dirs) {
+      const pkgPath = path.join(blocksDir, dir.name, "package.json");
+      const pkg = fs.existsSync(pkgPath)
+        ? JSON.parse(fs.readFileSync(pkgPath, "utf-8"))
+        : {};
+      blocks.push({
+        type: "block",
+        name: dir.name,
+        displayName: pkg.cmssy?.displayName || dir.name,
+        version: pkg.version || "1.0.0",
+        category: pkg.cmssy?.category || "other",
+        tags: pkg.cmssy?.tags || [],
+        description: pkg.description || "",
+        hasConfig: fs.existsSync(path.join(blocksDir, dir.name, "config.ts")),
+      });
+    }
+  }
+
+  const templatesDir = path.join(projectRoot, "templates");
+  if (fs.existsSync(templatesDir)) {
+    const dirs = fs
+      .readdirSync(templatesDir, { withFileTypes: true })
+      .filter((d) => d.isDirectory());
+
+    for (const dir of dirs) {
+      const pkgPath = path.join(templatesDir, dir.name, "package.json");
+      const pkg = fs.existsSync(pkgPath)
+        ? JSON.parse(fs.readFileSync(pkgPath, "utf-8"))
+        : {};
+      blocks.push({
+        type: "template",
+        name: dir.name,
+        displayName: pkg.cmssy?.displayName || dir.name,
+        version: pkg.version || "1.0.0",
+        category: pkg.cmssy?.category || "pages",
+        tags: pkg.cmssy?.tags || [],
+        description: pkg.description || "",
+        hasConfig: fs.existsSync(
+          path.join(templatesDir, dir.name, "config.ts"),
+        ),
+      });
+    }
+  }
+
+  return NextResponse.json(blocks);
+}

package/src/dev-app/app/api/config/route.ts

@@ -0,0 +1,98 @@
+import { NextResponse } from "next/server";
+import fs from "fs";
+import path from "path";
+
+const projectRoot = process.env.CMSSY_PROJECT_ROOT || process.cwd();
+
+function getEnvPath() {
+  return path.join(projectRoot, ".env");
+}
+
+function readEnv(): Record<string, string> {
+  const envPath = getEnvPath();
+  const result: Record<string, string> = {};
+  if (!fs.existsSync(envPath)) return result;
+  const content = fs.readFileSync(envPath, "utf-8");
+  for (const line of content.split("\n")) {
+    const match = line.match(/^([A-Z_]+)=(.*)$/);
+    if (match) result[match[1]] = match[2].trim();
+  }
+  return result;
+}
+
+function writeEnv(updates: Record<string, string>) {
+  const envPath = getEnvPath();
+  let content = fs.existsSync(envPath) ? fs.readFileSync(envPath, "utf-8") : "";
+
+  for (const [key, value] of Object.entries(updates)) {
+    const regex = new RegExp(`^(${key})=.*$`, "m");
+    if (regex.test(content)) {
+      content = content.replace(regex, `${key}=${value}`);
+    } else {
+      content = content.trimEnd() + "\n" + `${key}=${value}` + "\n";
+    }
+  }
+
+  fs.writeFileSync(envPath, content);
+}
+
+function maskToken(token: string | undefined): string | null {
+  if (!token || token.length < 8) return token ? "***" : null;
+  return token.substring(0, 3) + "***" + token.substring(token.length - 3);
+}
+
+function readCmssyConfig(): Record<string, any> | null {
+  const configPath = path.join(projectRoot, "cmssy.config.js");
+  if (!fs.existsSync(configPath)) return null;
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    const match = content.match(/export\s+default\s+({[\s\S]*});?/);
+    if (match)
+      return JSON.parse(match[1].replace(/,\s*}/g, "}").replace(/'/g, '"'));
+  } catch {}
+  return null;
+}
+
+export async function GET() {
+  const env = readEnv();
+  const cmssyConfig = readCmssyConfig();
+
+  return NextResponse.json({
+    env: {
+      apiUrl: env.CMSSY_API_URL || "https://api.cmssy.io/graphql",
+      hasToken: !!env.CMSSY_API_TOKEN,
+      maskedToken: maskToken(env.CMSSY_API_TOKEN),
+      workspaceId: env.CMSSY_WORKSPACE_ID || null,
+    },
+    project: cmssyConfig,
+  });
+}
+
+export async function PUT(request: Request) {
+  try {
+    const body = await request.json();
+    const updates: Record<string, string> = {};
+
+    if (body.apiUrl !== undefined) {
+      updates.CMSSY_API_URL = body.apiUrl;
+    }
+    if (body.apiToken !== undefined) {
+      updates.CMSSY_API_TOKEN = body.apiToken;
+    }
+    if (body.workspaceId !== undefined) {
+      updates.CMSSY_WORKSPACE_ID = body.workspaceId;
+    }
+
+    if (Object.keys(updates).length === 0) {
+      return NextResponse.json(
+        { error: "No values to update" },
+        { status: 400 },
+      );
+    }
+
+    writeEnv(updates);
+    return NextResponse.json({ success: true });
+  } catch (error: any) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/src/dev-app/app/api/context/route.ts

@@ -0,0 +1,126 @@
+import { NextResponse } from "next/server";
+import fs from "fs";
+import path from "path";
+
+const projectRoot = process.env.CMSSY_PROJECT_ROOT || process.cwd();
+const CONTEXT_PATH = path.join(projectRoot, ".cmssy", "dev-context.json");
+
+const DEFAULT_CONTEXT = {
+  locale: {
+    current: "en",
+    default: "en",
+    enabled: ["en"],
+  },
+  auth: null,
+  workspace: {
+    id: "dev-workspace",
+    slug: "dev",
+    name: "Dev Workspace",
+  },
+  isPreview: true,
+};
+
+const PRESETS: Record<string, any> = {
+  empty: {
+    locale: { current: "en", default: "en", enabled: ["en"] },
+    auth: null,
+    workspace: null,
+    isPreview: true,
+  },
+  "logged-in": {
+    locale: { current: "en", default: "en", enabled: ["en"] },
+    auth: {
+      isAuthenticated: true,
+      member: {
+        id: "dev-member-1",
+        email: "user@example.com",
+        profile: {
+          firstName: "Jane",
+          lastName: "Doe",
+          displayName: "Jane Doe",
+          avatarUrl: "",
+        },
+        role: "member",
+        verified: true,
+      },
+    },
+    workspace: { id: "dev-workspace", slug: "dev", name: "Dev Workspace" },
+    isPreview: true,
+  },
+  "multi-language": {
+    locale: { current: "en", default: "en", enabled: ["en", "pl", "de"] },
+    auth: null,
+    workspace: { id: "dev-workspace", slug: "dev", name: "Dev Workspace" },
+    isPreview: true,
+  },
+  "blog-posts": {
+    locale: { current: "en", default: "en", enabled: ["en"] },
+    auth: null,
+    workspace: { id: "dev-workspace", slug: "dev", name: "Dev Workspace" },
+    isPreview: true,
+    pages: {
+      posts: [
+        {
+          slug: "hello-world",
+          fullSlug: "/blog/hello-world",
+          displayName: { en: "Hello World" },
+          pageType: "post",
+        },
+        {
+          slug: "getting-started",
+          fullSlug: "/blog/getting-started",
+          displayName: { en: "Getting Started" },
+          pageType: "post",
+        },
+        {
+          slug: "advanced-tips",
+          fullSlug: "/blog/advanced-tips",
+          displayName: { en: "Advanced Tips" },
+          pageType: "post",
+        },
+      ],
+    },
+  },
+};
+
+export async function GET(request: Request) {
+  const url = new URL(request.url);
+
+  // Return presets list
+  if (url.searchParams.get("presets") === "true") {
+    return NextResponse.json({
+      presets: Object.keys(PRESETS),
+    });
+  }
+
+  // Return a specific preset
+  const preset = url.searchParams.get("preset");
+  if (preset && PRESETS[preset]) {
+    return NextResponse.json(PRESETS[preset]);
+  }
+
+  // Return saved context
+  let context = DEFAULT_CONTEXT;
+  if (fs.existsSync(CONTEXT_PATH)) {
+    try {
+      context = JSON.parse(fs.readFileSync(CONTEXT_PATH, "utf-8"));
+    } catch {
+      context = DEFAULT_CONTEXT;
+    }
+  }
+
+  return NextResponse.json(context);
+}
+
+export async function PUT(request: Request) {
+  try {
+    const body = await request.json();
+    const dir = path.dirname(CONTEXT_PATH);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(CONTEXT_PATH, JSON.stringify(body, null, 2));
+    return NextResponse.json({ success: true });
+  } catch (error: any) {
+    const status = error?.message?.includes("JSON") ? 400 : 500;
+    return NextResponse.json({ error: error.message }, { status });
+  }
+}

package/src/dev-app/app/api/preview/[name]/route.ts

@@ -0,0 +1,137 @@
+import { NextResponse } from "next/server";
+import fs from "fs";
+import path from "path";
+
+const projectRoot = process.env.CMSSY_PROJECT_ROOT || process.cwd();
+
+const SAFE_NAME_RE = /^[a-zA-Z0-9_-]+$/;
+
+function isValidName(name: string): boolean {
+  return SAFE_NAME_RE.test(name);
+}
+
+function resolveBlockPath(name: string): string | null {
+  if (!isValidName(name)) return null;
+  let blockPath = path.join(projectRoot, "blocks", name);
+  if (fs.existsSync(blockPath)) return blockPath;
+  blockPath = path.join(projectRoot, "templates", name);
+  return fs.existsSync(blockPath) ? blockPath : null;
+}
+
+function getVariants(blockPath: string): string[] {
+  const previewsDir = path.join(blockPath, "previews");
+  if (!fs.existsSync(previewsDir)) return [];
+  return fs
+    .readdirSync(previewsDir)
+    .filter((f) => f.endsWith(".json"))
+    .map((f) => f.replace(/\.json$/, ""))
+    .filter((name) => SAFE_NAME_RE.test(name))
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function getPreviewPath(blockPath: string, variant?: string): string {
+  if (variant && isValidName(variant)) {
+    const variantPath = path.join(blockPath, "previews", `${variant}.json`);
+    if (fs.existsSync(variantPath)) return variantPath;
+  }
+  return path.join(blockPath, "preview.json");
+}
+
+export async function GET(
+  request: Request,
+  { params }: { params: Promise<{ name: string }> },
+) {
+  const { name } = await params;
+  if (!isValidName(name)) {
+    return NextResponse.json({ error: "Invalid name" }, { status: 400 });
+  }
+
+  const blockPath = resolveBlockPath(name);
+  if (!blockPath) {
+    return NextResponse.json({ error: "Not found" }, { status: 404 });
+  }
+
+  const url = new URL(request.url);
+  const variant = url.searchParams.get("variant") || undefined;
+
+  if (url.searchParams.get("list") === "variants") {
+    return NextResponse.json({ variants: getVariants(blockPath) });
+  }
+
+  const previewPath = getPreviewPath(blockPath, variant);
+  let data = {};
+  if (fs.existsSync(previewPath)) {
+    try {
+      data = JSON.parse(fs.readFileSync(previewPath, "utf-8"));
+    } catch {
+      data = {};
+    }
+  }
+
+  return NextResponse.json({
+    data,
+    variants: getVariants(blockPath),
+    currentVariant: variant || null,
+  });
+}
+
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ name: string }> },
+) {
+  const { name } = await params;
+  if (!isValidName(name)) {
+    return NextResponse.json({ error: "Invalid name" }, { status: 400 });
+  }
+
+  const blockPath = resolveBlockPath(name);
+  if (!blockPath) {
+    return NextResponse.json({ error: "Not found" }, { status: 404 });
+  }
+
+  const url = new URL(request.url);
+  const variant = url.searchParams.get("variant") || undefined;
+  const action = url.searchParams.get("action");
+
+  // Validate variant param if present
+  if (variant && !isValidName(variant)) {
+    return NextResponse.json({ error: "Invalid variant" }, { status: 400 });
+  }
+
+  // Save as new variant
+  if (action === "save-variant") {
+    const body = await request.json();
+    const variantName = body.variantName;
+    if (!variantName || !isValidName(variantName)) {
+      return NextResponse.json(
+        {
+          error:
+            "Invalid variant name (use alphanumeric, hyphens, underscores)",
+        },
+        { status: 400 },
+      );
+    }
+    const previewsDir = path.join(blockPath, "previews");
+    fs.mkdirSync(previewsDir, { recursive: true });
+    const variantPath = path.join(previewsDir, `${variantName}.json`);
+    const dataToWrite = body.data ?? {};
+    fs.writeFileSync(variantPath, JSON.stringify(dataToWrite, null, 2));
+    return NextResponse.json({ success: true, variant: variantName });
+  }
+
+  // Delete variant
+  if (action === "delete-variant" && variant) {
+    const variantPath = path.join(blockPath, "previews", `${variant}.json`);
+    if (fs.existsSync(variantPath)) {
+      fs.unlinkSync(variantPath);
+    }
+    return NextResponse.json({ success: true });
+  }
+
+  // Regular save
+  const body = await request.json();
+  const previewPath = getPreviewPath(blockPath, variant);
+  fs.writeFileSync(previewPath, JSON.stringify(body, null, 2));
+
+  return NextResponse.json({ success: true });
+}

package/src/dev-app/app/api/workspaces/route.ts

@@ -0,0 +1,124 @@
+import { NextResponse } from "next/server";
+import fs from "fs";
+import path from "path";
+
+const projectRoot = process.env.CMSSY_PROJECT_ROOT || process.cwd();
+
+function loadEnvConfig(): {
+  apiUrl: string;
+  apiToken: string | null;
+  workspaceId: string | null;
+} {
+  const envPath = path.join(projectRoot, ".env");
+  const config: any = {
+    apiUrl: "https://api.cmssy.io/graphql",
+    apiToken: null,
+    workspaceId: null,
+  };
+  if (!fs.existsSync(envPath)) return config;
+  const content = fs.readFileSync(envPath, "utf-8");
+  for (const line of content.split("\n")) {
+    const match = line.match(/^(CMSSY_\w+)=(.*)$/);
+    if (!match) continue;
+    const [, key, val] = match;
+    if (key === "CMSSY_API_URL") config.apiUrl = val.trim();
+    if (key === "CMSSY_API_TOKEN") config.apiToken = val.trim() || null;
+    if (key === "CMSSY_WORKSPACE_ID") config.workspaceId = val.trim() || null;
+  }
+  return config;
+}
+
+const MY_WORKSPACES_QUERY = `
+  query MyWorkspaces {
+    myWorkspaces {
+      id
+      slug
+      name
+      myRole { name slug }
+    }
+  }
+`;
+
+const WORKSPACE_BLOCKS_QUERY = `
+  query GetWorkspaceBlocks {
+    workspaceBlocks {
+      id
+      blockType
+      name
+      version
+    }
+  }
+`;
+
+export async function GET() {
+  const config = loadEnvConfig();
+
+  if (!config.apiToken) {
+    return NextResponse.json({ connected: false, reason: "no_token" });
+  }
+
+  try {
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.apiToken}`,
+    };
+
+    const wsRes = await fetch(config.apiUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query: MY_WORKSPACES_QUERY }),
+    });
+    const wsData = await wsRes.json();
+
+    if (wsData.errors?.length) {
+      return NextResponse.json({
+        connected: false,
+        reason: "auth_error",
+        error: wsData.errors[0].message,
+      });
+    }
+
+    const workspaces = wsData.data?.myWorkspaces || [];
+
+    let targetWorkspace = null;
+    if (config.workspaceId) {
+      targetWorkspace = workspaces.find(
+        (w: any) => w.id === config.workspaceId,
+      );
+    }
+    if (!targetWorkspace && workspaces.length > 0) {
+      targetWorkspace = workspaces[0];
+    }
+
+    let publishedBlocks: any[] = [];
+    if (targetWorkspace) {
+      const blocksRes = await fetch(config.apiUrl, {
+        method: "POST",
+        headers: {
+          ...headers,
+          "x-workspace-id": targetWorkspace.id,
+        },
+        body: JSON.stringify({ query: WORKSPACE_BLOCKS_QUERY }),
+      });
+      const blocksData = await blocksRes.json();
+      publishedBlocks = blocksData.data?.workspaceBlocks || [];
+    }
+
+    return NextResponse.json({
+      connected: true,
+      workspace: targetWorkspace,
+      workspaces,
+      publishedBlocks: publishedBlocks.map((b: any) => ({
+        blockType: b.blockType,
+        name: b.name,
+        version: b.version || "1.0.0",
+      })),
+    });
+  } catch (error: any) {
+    return NextResponse.json({
+      connected: false,
+      reason: "network_error",
+      error: error.message,
+    });
+  }
+}

package/src/dev-app/app/layout.tsx

@@ -0,0 +1,18 @@
+import type { Metadata } from "next";
+import type { ReactNode } from "react";
+import "./globals.css";
+
+export const metadata: Metadata = {
+  title: "Cmssy Dev Server",
+  icons: {
+    icon: "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'%3E%3Crect width='100' height='100' rx='20' fill='%23667eea'/%3E%3Ctext x='50' y='70' font-size='60' font-weight='bold' text-anchor='middle' fill='white' font-family='system-ui'%3EC%3C/text%3E%3C/svg%3E",
+  },
+};
+
+export default function RootLayout({ children }: { children: ReactNode }) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  );
+}