@cmssy/cli 1.0.0 → 9.1.1

package/dist/index.js

@@ -0,0 +1,437 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { createInterface } from "readline/promises";
+
+// src/link.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import {
+  buildEditorUrl,
+  checkDraftSecret,
+  checkWorkspaceReachable
+} from "@cmssy/core/preflight";
+
+// src/admin-client.ts
+var DEFAULT_ADMIN_API_URL = "https://api.cmssy.io/graphql";
+var BAD_TOKEN_HINT = {
+  message: "the cmssy API rejected the token",
+  fix: "create an API token in the cmssy dashboard (Settings \u2192 API Tokens) and pass it via --token or CMSSY_API_TOKEN"
+};
+var NEEDS_PAGES_EDIT_HINT = {
+  message: "the token's user cannot read this workspace's settings",
+  fix: "the token's user needs the PAGES_EDIT permission in the selected workspace"
+};
+var CliError = class extends Error {
+  fix;
+  constructor(message, fix) {
+    super(message);
+    this.name = "CliError";
+    this.fix = fix;
+  }
+};
+function isDenied(errors, status) {
+  return status === 401 || status === 403 || errors.some(
+    (error) => error.extensions?.code === "UNAUTHENTICATED" || error.extensions?.code === "FORBIDDEN" || /unauthenticated|unauthorized|not authorized|not authenticated|invalid token|permission|forbidden|not allowed|access denied/i.test(
+      error.message ?? ""
+    )
+  );
+}
+async function adminGraphql(query, variables, options) {
+  const doFetch = options.fetch ?? globalThis.fetch;
+  const url = options.apiUrl?.trim() || DEFAULT_ADMIN_API_URL;
+  let response;
+  try {
+    response = await doFetch(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${options.token}`,
+        ...options.workspaceId ? { "x-workspace-id": options.workspaceId } : {}
+      },
+      body: JSON.stringify({ query, variables })
+    });
+  } catch {
+    throw new CliError(
+      `cannot reach the cmssy API at ${url}`,
+      "check your network connection and CMSSY_API_URL (leave it unset for cmssy cloud)"
+    );
+  }
+  let envelope = null;
+  try {
+    envelope = await response.json();
+  } catch {
+    envelope = null;
+  }
+  const errors = Array.isArray(envelope?.errors) ? envelope.errors : [];
+  if (isDenied(errors, response.status)) {
+    const denied = options.denied ?? BAD_TOKEN_HINT;
+    throw new CliError(denied.message, denied.fix);
+  }
+  if (errors.length > 0) {
+    throw new CliError(
+      `the cmssy API rejected the request - ${errors.map((error) => error.message ?? "GraphQL error").join("; ")}`
+    );
+  }
+  if (!response.ok || envelope?.data === void 0) {
+    throw new CliError(`the cmssy API responded with HTTP ${response.status}`);
+  }
+  return envelope.data;
+}
+var WORKSPACES_MINE_QUERY = `query CliWorkspacesMine {
+  workspace {
+    mine {
+      id
+      slug
+      name
+      organizationSlug
+    }
+  }
+}`;
+var DRAFT_SECRET_QUERY = `query CliDraftSecret {
+  workspace {
+    draftSecret
+  }
+}`;
+var UPDATE_PREVIEW_URL_MUTATION = `mutation CliSetPreviewUrl($input: UpdateSiteConfigInput!) {
+  siteConfig {
+    update(input: $input) {
+      previewUrl
+    }
+  }
+}`;
+async function fetchMyWorkspaces(options) {
+  const data = await adminGraphql(WORKSPACES_MINE_QUERY, {}, options);
+  return data.workspace.mine;
+}
+async function fetchDraftSecret(options) {
+  const data = await adminGraphql(
+    DRAFT_SECRET_QUERY,
+    {},
+    { ...options, denied: NEEDS_PAGES_EDIT_HINT }
+  );
+  return data.workspace.draftSecret;
+}
+async function setPreviewUrl(previewUrl, options) {
+  await adminGraphql(
+    UPDATE_PREVIEW_URL_MUTATION,
+    { input: { previewUrl } },
+    { ...options, denied: NEEDS_PAGES_EDIT_HINT }
+  );
+}
+
+// src/env-file.ts
+function parseEnvFile(content) {
+  const vars = {};
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const withoutExport = line.replace(/^export\s+/, "");
+    const separator = withoutExport.indexOf("=");
+    if (separator <= 0) continue;
+    const key = withoutExport.slice(0, separator).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
+    let value = withoutExport.slice(separator + 1).trim();
+    const quoted = value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"));
+    if (quoted) {
+      value = value.slice(1, -1);
+    } else {
+      const comment = value.indexOf(" #");
+      if (comment !== -1) value = value.slice(0, comment).trim();
+    }
+    vars[key] = value;
+  }
+  return vars;
+}
+function applyEnv(vars, env) {
+  const applied = [];
+  for (const [key, value] of Object.entries(vars)) {
+    if (env[key] !== void 0) continue;
+    env[key] = value;
+    applied.push(key);
+  }
+  return applied;
+}
+
+// src/env-write.ts
+function needsQuoting(value) {
+  return /[\s#"']/.test(value) || value === "";
+}
+function serialize(key, value) {
+  return needsQuoting(value) ? `${key}="${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : `${key}=${value}`;
+}
+function mergeEnvContent(existing, updates) {
+  const pending = new Map(Object.entries(updates));
+  const lines = existing ? existing.split(/\r?\n/) : [];
+  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  const merged = lines.map((line) => {
+    const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line);
+    const key = match?.[1];
+    if (!key || !pending.has(key)) return line;
+    const value = pending.get(key);
+    pending.delete(key);
+    return serialize(key, value);
+  });
+  for (const [key, value] of pending) {
+    merged.push(serialize(key, value));
+  }
+  return `${merged.join("\n")}
+`;
+}
+
+// src/format.ts
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+var YELLOW = "\x1B[33m";
+var CYAN = "\x1B[36m";
+var RESET = "\x1B[0m";
+function useColor(env = process.env, isTty = Boolean(process.stdout.isTTY)) {
+  return isTty && env.NO_COLOR === void 0;
+}
+function paint(text, color, colored) {
+  return colored ? `${color}${text}${RESET}` : text;
+}
+function formatResult(result, colored = useColor()) {
+  if (result.status === "ok") {
+    return `${paint("\u2713", GREEN, colored)} ${result.message}`;
+  }
+  if (result.status === "unknown") {
+    return `${paint("?", YELLOW, colored)} ${result.message}`;
+  }
+  const fix = result.fix ? `
+  fix: ${result.fix}` : "";
+  return `${paint("\u2717", RED, colored)} ${result.message}${fix}`;
+}
+function formatEditorLink(url, colored = useColor()) {
+  return `
+Edit this site visually:
+  ${paint(url, CYAN, colored)}
+`;
+}
+
+// src/link.ts
+var ENV_FILES = [".env.local", ".env"];
+function loadEnvFiles(cwd, env) {
+  for (const file of ENV_FILES) {
+    const path = join(cwd, file);
+    if (!existsSync(path)) continue;
+    applyEnv(parseEnvFile(readFileSync(path, "utf8")), env);
+  }
+}
+function resolveToken(options, deps) {
+  const token = options.token?.trim() || deps.env.CMSSY_API_TOKEN?.trim();
+  if (!token) {
+    throw new CliError(
+      "no API token given",
+      "create an API token in the cmssy dashboard (Settings \u2192 API Tokens), then run cmssy link --token cs_... or set CMSSY_API_TOKEN"
+    );
+  }
+  return token;
+}
+function describeWorkspace(workspace) {
+  const org = workspace.organizationSlug ?? "?";
+  return `${workspace.name} (${org}/${workspace.slug})`;
+}
+async function selectWorkspace(workspaces, options, deps) {
+  if (workspaces.length === 0) {
+    throw new CliError(
+      "the token's user has no workspaces",
+      "create a workspace in the cmssy dashboard, or use a token from a user who is a member of one"
+    );
+  }
+  const slugs = workspaces.map((workspace) => `${workspace.organizationSlug}/${workspace.slug}`).join(", ");
+  if (options.workspace) {
+    const wanted = options.workspace.trim();
+    const match = workspaces.find(
+      (workspace) => workspace.slug === wanted || `${workspace.organizationSlug}/${workspace.slug}` === wanted
+    );
+    if (!match) {
+      throw new CliError(
+        `no workspace named "${wanted}"`,
+        `pass one of: ${slugs}`
+      );
+    }
+    return match;
+  }
+  if (workspaces.length === 1) {
+    return workspaces[0];
+  }
+  if (!deps.isTty) {
+    throw new CliError(
+      "several workspaces are available and there is no terminal to ask in",
+      `pass --workspace <slug> - one of: ${slugs}`
+    );
+  }
+  deps.log("Which workspace should this app be linked to?");
+  workspaces.forEach((workspace, index) => {
+    deps.log(`  ${index + 1}. ${describeWorkspace(workspace)}`);
+  });
+  const answer = await deps.ask(`Workspace [1-${workspaces.length}]: `);
+  const choice = Number(answer.trim());
+  const selected = Number.isInteger(choice) && choice >= 1 && choice <= workspaces.length ? workspaces[choice - 1] : void 0;
+  if (!selected) {
+    throw new CliError(
+      `"${answer.trim()}" is not a number between 1 and ${workspaces.length}`,
+      "run cmssy link again, or pass --workspace <slug>"
+    );
+  }
+  return selected;
+}
+function resolvePreviewUrl(options) {
+  if (!options.previewUrl) return null;
+  let origin;
+  try {
+    origin = new URL(options.previewUrl).origin;
+  } catch {
+    throw new CliError(
+      `"${options.previewUrl}" is not a valid URL`,
+      "pass --preview-url with your DEPLOYED site origin, e.g. --preview-url https://example.com"
+    );
+  }
+  const { hostname } = new URL(origin);
+  if (hostname === "localhost" || hostname === "127.0.0.1") {
+    throw new CliError(
+      "the workspace preview URL is the DEPLOYED site every editor in the workspace previews - not your localhost",
+      "for local development, toggle dev mode in the cmssy editor and enter your local host there (per user, nothing shared)"
+    );
+  }
+  return origin;
+}
+function writeEnvLocal(cwd, updates) {
+  const path = join(cwd, ".env.local");
+  const existing = existsSync(path) ? readFileSync(path, "utf8") : null;
+  writeFileSync(path, mergeEnvContent(existing, updates));
+}
+async function runLink(options, deps) {
+  const { cwd, env, log } = deps;
+  try {
+    loadEnvFiles(cwd, env);
+    const token = resolveToken(options, deps);
+    const admin = {
+      token,
+      apiUrl: env.CMSSY_API_URL,
+      fetch: deps.fetch
+    };
+    const workspaces = await fetchMyWorkspaces(admin);
+    const workspace = await selectWorkspace(workspaces, options, deps);
+    const orgSlug = workspace.organizationSlug;
+    if (!orgSlug) {
+      throw new CliError(
+        `workspace ${workspace.slug} has no organization slug`,
+        "open the workspace in the cmssy dashboard once, then run cmssy link again"
+      );
+    }
+    log(
+      formatResult({
+        status: "ok",
+        message: `linking to ${describeWorkspace(workspace)}`
+      })
+    );
+    const draftSecret = await fetchDraftSecret({
+      ...admin,
+      workspaceId: workspace.id
+    });
+    log(formatResult({ status: "ok", message: "fetched the draft secret" }));
+    const previewUrl = resolvePreviewUrl(options);
+    if (previewUrl) {
+      await setPreviewUrl(previewUrl, { ...admin, workspaceId: workspace.id });
+      log(
+        formatResult({
+          status: "ok",
+          message: `set the workspace preview URL to ${previewUrl}`
+        })
+      );
+    } else {
+      log(
+        formatResult({
+          status: "unknown",
+          message: "preview URL left unchanged - pass --preview-url <deployed origin> to set it; for localhost use the editor dev-mode switch"
+        })
+      );
+    }
+    writeEnvLocal(cwd, {
+      CMSSY_ORG_SLUG: orgSlug,
+      CMSSY_WORKSPACE_SLUG: workspace.slug,
+      CMSSY_DRAFT_SECRET: draftSecret
+    });
+    log(
+      formatResult({
+        status: "ok",
+        message: "wrote CMSSY_ORG_SLUG, CMSSY_WORKSPACE_SLUG and CMSSY_DRAFT_SECRET to .env.local"
+      })
+    );
+    const preflight = {
+      apiUrl: env.CMSSY_API_URL,
+      org: orgSlug,
+      workspaceSlug: workspace.slug,
+      draftSecret,
+      fetch: deps.fetch
+    };
+    const reachable = await checkWorkspaceReachable(preflight);
+    log(formatResult(reachable));
+    const secretResult = await checkDraftSecret(preflight);
+    log(formatResult(secretResult));
+    log(formatEditorLink(buildEditorUrl(preflight)));
+    return reachable.status === "fail" || secretResult.status === "fail" ? 1 : 0;
+  } catch (error) {
+    if (error instanceof CliError) {
+      log(
+        formatResult({
+          status: "fail",
+          message: error.message,
+          fix: error.fix
+        })
+      );
+      return 1;
+    }
+    log(
+      formatResult({
+        status: "fail",
+        message: error instanceof Error ? error.message : String(error)
+      })
+    );
+    return 1;
+  }
+}
+
+// src/index.ts
+var USAGE = "usage: cmssy link [--token <cs_...>] [--workspace <slug>] [--preview-url <url>]";
+function flagValue(args, name) {
+  const index = args.findIndex((arg) => arg === name);
+  if (index !== -1) return args[index + 1];
+  return args.find((arg) => arg.startsWith(`${name}=`))?.slice(name.length + 1);
+}
+async function main() {
+  const [command, ...args] = process.argv.slice(2);
+  if (command !== "link") {
+    console.error(USAGE);
+    process.exitCode = command === void 0 || command === "--help" ? 0 : 1;
+    return;
+  }
+  const rl = process.stdin.isTTY ? createInterface({ input: process.stdin, output: process.stdout }) : null;
+  try {
+    process.exitCode = await runLink(
+      {
+        token: flagValue(args, "--token"),
+        workspace: flagValue(args, "--workspace"),
+        previewUrl: flagValue(args, "--preview-url")
+      },
+      {
+        cwd: process.cwd(),
+        env: process.env,
+        log: (line) => console.log(line),
+        fetch: globalThis.fetch,
+        isTty: rl !== null,
+        ask: (question) => rl ? rl.question(question) : Promise.resolve("")
+      }
+    );
+  } finally {
+    rl?.close();
+  }
+}
+main().catch((error) => {
+  console.error(
+    `cmssy: ${error instanceof Error ? error.message : String(error)}`
+  );
+  process.exitCode = 1;
+});

package/package.json

@@ -1,55 +1,41 @@
 {
   "name": "@cmssy/cli",
-  "version": "1.0.0",
-  "description": "CLI for wiring a Next.js app to a headless cmssy workspace",
-  "type": "module",
-  "bin": {
-    "cmssy": "./dist/cli.js"
-  },
-  "files": [
-    "dist",
-    "templates",
-    "README.md",
-    "LICENSE"
-  ],
+  "version": "9.1.1",
+  "description": "One command to connect an app to a cmssy workspace: `cmssy link` writes .env.local, sets the preview URL and verifies the editor wiring.",
   "keywords": [
     "cmssy",
     "cli",
-    "headless",
-    "cms",
-    "nextjs"
+    "link"
   ],
-  "author": "Cmssy Team",
-  "license": "MIT",
+  "homepage": "https://cmssy.com",
   "repository": {
     "type": "git",
-    "url": "https://github.com/cmssy-io/cmssy-cli.git"
-  },
-  "homepage": "https://github.com/cmssy-io/cmssy-cli#readme",
-  "bugs": {
-    "url": "https://github.com/cmssy-io/cmssy-cli/issues"
-  },
-  "engines": {
-    "node": ">=18.18.0"
+    "url": "git+https://github.com/cmssy-io/cmssy-sdk.git",
+    "directory": "packages/cli"
   },
+  "type": "module",
+  "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
+  "bin": {
+    "cmssy": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
   "dependencies": {
-    "@clack/prompts": "^1.6.0",
-    "picocolors": "^1.1.1"
+    "@cmssy/core": "9.1.1"
   },
   "devDependencies": {
-    "@types/node": "^26.0.1",
-    "tsup": "^8.5.1",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.9"
+    "@types/node": "^20.0.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0"
   },
   "scripts": {
     "build": "tsup",
-    "dev": "tsup --watch",
-    "typecheck": "tsc --noEmit",
     "test": "vitest run",
-    "test:watch": "vitest"
+    "typecheck": "tsc --noEmit"
   }
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Cmssy Team
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,91 +0,0 @@
-# @cmssy/cli
-
-The `cmssy` CLI wires cmssy into your existing [Next.js](https://nextjs.org) (App Router) app
-and helps you grow it with blocks. It does not scaffold a Next app - bring your own
-(`npx create-next-app@latest`).
-
-```bash
-npx create-next-app@latest my-site   # your app, your way
-cd my-site
-npx @cmssy/cli init                  # add cmssy
-```
-
-Requires **Node 18.18+** and an existing **Next.js App Router** project.
-
-## Commands
-
-### `cmssy init [dir]`
-
-Add the cmssy wiring to an existing Next.js App Router app, then link it to a workspace.
-Idempotent - it never overwrites a file you already have; skipped files are reported.
-
-It writes: `cmssy.config.ts`, a catch-all `app/[[...path]]/page.tsx`, the draft route,
-`proxy.ts` (edit-mode + CSP), the block registry, the lazy editor, and one self-styled example
-`hero` block (a CSS Module - cmssy does not impose a styling system). `next.config.mjs` is added
-only if you don't already have one. Then it links and installs dependencies.
-
-```bash
-cmssy init                 # wire the current directory
-cmssy init --pm pnpm       # choose the package manager (npm | pnpm | yarn | bun)
-cmssy init --skip-install  # write files, install later
-cmssy init --no-link       # skip the workspace prompt
-```
-
-### `cmssy link`
-
-Connect an already-initialized project to a workspace. Prompts for the workspace slug and draft
-secret (both from **cmssy dashboard → Settings → Headless**), validates the slug against the
-delivery API, and writes them to `.env` without touching your other variables.
-
-```bash
-cmssy link
-cmssy link --slug my-workspace --secret <draft-secret>   # non-interactive
-```
-
-### `cmssy add block <name>`
-
-Scaffold a new block and register it in `cmssy/blocks.ts`. The name is normalized: a folder in
-kebab-case, a PascalCase component, a camelCase registry export.
-
-```bash
-cmssy add block "Feature Grid"
-# -> blocks/feature-grid/{block.ts, FeatureGrid.tsx, FeatureGrid.module.css}
-#    registered as featureGridBlock
-```
-
-### `cmssy doctor`
-
-Diagnose a project's cmssy setup: required files, `@cmssy/*` install + version alignment, env
-vars, and that the block registry's imports resolve. Exits non-zero on a hard failure.
-
-```bash
-cmssy doctor
-```
-
-## What "linked" means
-
-Only two values are required (cmssy cloud provides the rest):
-
-| Variable               | Where to find it                                      |
-| ---------------------- | ----------------------------------------------------- |
-| `CMSSY_WORKSPACE_SLUG` | cmssy dashboard → Settings → Headless                 |
-| `CMSSY_DRAFT_SECRET`   | cmssy dashboard → Settings → Headless (per-workspace) |
-
-## Docs
-
-- [cmssy docs](https://www.cmssy.com/docs)
-- [Installation](https://www.cmssy.com/docs/installation) · [Quickstart](https://www.cmssy.com/docs/quickstart)
-- Built on the cmssy SDK: [`@cmssy/next` + `@cmssy/react`](https://github.com/cmssy-io/cmssy-sdk)
-
-## Contributing
-
-```bash
-pnpm install
-pnpm run build      # tsup -> dist/cli.js
-pnpm run typecheck
-pnpm test           # vitest
-```
-
-## License
-
-MIT