@cmssy/cli 0.22.4 → 9.1.0

package/dist/index.js

@@ -0,0 +1,435 @@
+#!/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"];
+var DEFAULT_PREVIEW_URL = "http://localhost:3000";
+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;
+}
+async function resolvePreviewUrl(options, deps) {
+  if (options.previewUrl) {
+    try {
+      return new URL(options.previewUrl).origin;
+    } catch {
+      throw new CliError(
+        `"${options.previewUrl}" is not a valid URL`,
+        "pass --preview-url with a full origin, e.g. --preview-url http://localhost:3000"
+      );
+    }
+  }
+  if (!deps.isTty) return null;
+  const answer = await deps.ask(
+    `Set the workspace preview URL to ${DEFAULT_PREVIEW_URL}? (Y/n) `
+  );
+  return /^(y(es)?)?$/i.test(answer.trim()) ? DEFAULT_PREVIEW_URL : null;
+}
+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 = await resolvePreviewUrl(options, deps);
+    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 to set it`
+        })
+      );
+    }
+    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,102 +1,41 @@
 {
   "name": "@cmssy/cli",
-  "version": "0.22.4",
-  "description": "Unified CLI for building and publishing blocks to Cmssy design library",
-  "type": "module",
-  "bin": {
-    "cmssy": "./dist/cli.js"
-  },
-  "exports": {
-    ".": "./dist/cli.js",
-    "./config": "./config.js",
-    "./test": "./test.js"
-  },
-  "scripts": {
-    "build": "tsc && tsc config.ts --module esnext --target esnext --moduleResolution bundler && tsc config.ts --declaration --emitDeclarationOnly --module esnext --target esnext --moduleResolution bundler && node scripts/copy-assets.mjs",
-    "dev": "tsc --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "prepare": "npm run build"
-  },
+  "version": "9.1.0",
+  "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",
-    "design-library",
     "cli",
-    "cms"
+    "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"
-  },
-  "files": [
-    "dist",
-    "src/dev-app",
-    "config.js",
-    "config.d.ts",
-    "test.js",
-    "test.d.ts",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "node": ">=18.0.0"
+    "url": "git+https://github.com/cmssy-io/cmssy-sdk.git",
+    "directory": "packages/cli"
   },
+  "type": "module",
+  "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "@cmssy/types": "^0.14.0",
-    "@tailwindcss/postcss": "^4.1.18",
-    "archiver": "^7.0.1",
-    "chalk": "^5.3.0",
-    "chokidar": "^4.0.1",
-    "commander": "^12.1.0",
-    "dotenv": "^16.4.7",
-    "esbuild": "^0.24.0",
-    "form-data": "^4.0.1",
-    "fs-extra": "^11.2.0",
-    "glob": "^11.0.0",
-    "graphql": "^16.9.0",
-    "graphql-request": "^7.1.2",
-    "inquirer": "^10.0.0",
-    "node-fetch": "^3.3.2",
-    "ora": "^8.0.1",
-    "postcss": "^8.4.49",
-    "postcss-import": "^16.1.1",
-    "semver": "^7.6.3",
-    "tsx": "^4.21.0"
-  },
-  "peerDependencies": {
-    "next": ">=15.0.0",
-    "react": ">=19.0.0",
-    "react-dom": ">=19.0.0"
+  "bin": {
+    "cmssy": "./dist/index.js"
   },
-  "peerDependenciesMeta": {
-    "next": {
-      "optional": true
-    }
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@cmssy/core": "9.1.0"
   },
   "devDependencies": {
-    "@testing-library/react": "^16",
-    "@types/archiver": "^7.0.0",
-    "@types/form-data": "^2.5.2",
-    "@types/fs-extra": "^11.0.4",
-    "@types/inquirer": "^9.0.7",
-    "@types/node": "^22.10.2",
-    "@types/node-fetch": "^2.6.13",
-    "@types/postcss-import": "^14.0.3",
-    "@types/react": "^19",
-    "@types/react-dom": "^19",
-    "@types/semver": "^7.7.1",
-    "@vitest/coverage-v8": "^3.2.4",
-    "typescript": "^5.7.2",
-    "vitest": "^3.2.4"
+    "@types/node": "^20.0.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "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.