creght-cli 0.1.16

package/README.md

@@ -0,0 +1,495 @@
+# Cregh CLI
+
+Cregh CLI is a thin local bridge for syncing site code between a local directory and Cregh.
+
+The CLI can also run a local Vite preview for pulled Cregh projects. Cregh remains responsible for cloud rendering, CMS, assets, and the realtime preview environment.
+
+## Install
+
+Using npm:
+
+```bash
+npm install -g creght-cli
+```
+
+Build from source:
+
+```bash
+cd /Users/bysir/dev/bysir/creght-cli
+go build -o creght ./cmd/creght
+```
+
+Optional:
+
+```bash
+mv ./creght /usr/local/bin/creght
+```
+
+## Login
+
+For production:
+
+```bash
+creght login
+```
+
+For local development:
+
+```bash
+CREGHT_API_HOST=http://localhost:8433 creght login --web=http://localhost:5173
+```
+
+The command opens a browser authorization page. After authorization succeeds, the CLI stores the token in:
+
+```text
+~/Library/Application Support/creght/config.json
+```
+
+The config file contains the API host and CLI token.
+
+When `--web` is omitted, the CLI uses `CREGHT_WEB_HOST` if set. For local API hosts such as `localhost` or `127.0.0.1`, it defaults to `http://localhost:5173`.
+For production, the default API host and default web host are both `https://creght.cn`.
+
+## Logout
+
+Remove the saved CLI config:
+
+```bash
+creght logout
+```
+
+This clears the saved token and any saved API host. The next command will use the production default unless you set `CREGHT_API_HOST`.
+
+## List Projects
+
+```bash
+creght project list
+```
+
+For local development:
+
+```bash
+CREGHT_API_HOST=http://localhost:8433 creght project list
+```
+
+Example output:
+
+```text
+project_id    Project Name
+  project_id/site_id    Site Name
+```
+
+Use the `project_id/site_id` value with `pull`, `push`, and `sync`.
+
+## Create Project
+
+Create a new project:
+
+```bash
+creght project create --name="My Project"
+```
+
+For local development:
+
+```bash
+CREGHT_API_HOST=http://localhost:8433 creght project create --name="My Project"
+```
+
+You can also create from an existing project or template when the backend allows it:
+
+```bash
+creght project create --name="My Project" --from_id=<project_id>
+creght project create --name="My Project" --tpl_id=<template_id>
+```
+
+## Pull Site Code
+
+Download the current remote site files into a local directory:
+
+```bash
+creght pull --site_id=<project_id>/<site_id> --dir=./mysite
+```
+
+For local development:
+
+```bash
+CREGHT_API_HOST=http://localhost:8433 creght pull --site_id=<project_id>/<site_id> --dir=./mysite
+```
+
+The command writes remote files such as `/page/...`, `/component/...`, and `creght.config.ts` into the target directory.
+
+## Local Vite Preview
+
+Cregh projects pulled by the CLI usually do not have their own `package.json`
+or `node_modules`. The local preview plugin therefore uses Vite only for local
+file serving and TSX transpilation; third-party packages continue to resolve
+through the Cregh import map, matching the Web editor preview model. In
+`creght dev`, the CLI loads the platform import map from server system info and
+passes it to the Vite plugin; the plugin's local map is only a fallback.
+
+Install Vite in the local project folder:
+
+```bash
+cd ./mysite
+npm init -y
+npm install -D vite esbuild creght-cli
+```
+
+Create `vite.config.mjs`:
+
+```js
+import { defineConfig } from 'vite'
+import creght from 'creght-cli/vite'
+
+export default defineConfig({
+  plugins: [
+    creght({
+      apiHost: 'https://creght.cn',
+      projectId: '<project_id>',
+      // token: process.env.CREGHT_TOKEN,
+    }),
+  ],
+})
+```
+
+Run it:
+
+```bash
+npx vite --host 0.0.0.0
+```
+
+The plugin maps `/page/Index.tsx` to `/`, `/page/About.tsx` to `/about`, starts
+from the platform import map, merges `creght.config.ts` import-map entries,
+loads `/index.css` through the Tailwind browser runtime, proxies local `/api/*`
+requests to `apiHost`, calls page `getServerSideProps()` in the browser for a
+preview-only first render, and uses Vite HMR to re-import the current page
+module after local file changes without a full page reload.
+
+## Push Local Changes
+
+Push the current local directory snapshot to Cregh and exit:
+
+```bash
+creght push --site_id=<project_id>/<site_id> --dir=./mysite
+```
+
+For local development:
+
+```bash
+CREGHT_API_HOST=http://localhost:8433 creght push --site_id=<project_id>/<site_id> --dir=./mysite
+```
+
+The CLI scans the local directory and calls the existing Cregh `site_action`
+API to create or update remote files.
+
+## Sync Local Changes
+
+Run watch mode for a local directory:
+
+```bash
+creght sync --site_id=<project_id>/<site_id> --dir=./mysite
+```
+
+For local development:
+
+```bash
+CREGHT_API_HOST=http://localhost:8433 creght sync --site_id=<project_id>/<site_id> --dir=./mysite
+```
+
+`sync` first pushes the current local snapshot, then keeps running and
+automatically listens for local file changes. When a file is changed locally,
+the CLI calls the existing Cregh `site_action` API and updates the remote site
+in realtime. The command also prints the remote preview URL when available.
+
+## Local Web Editor Bidirectional Sync
+
+Run local files and the online Cregh editor against the same cloud realtime
+files:
+
+```bash
+creght dev --site_id=<project_id>/<site_id> --dir=./mysite
+```
+
+For local backend or web development:
+
+```bash
+CREGHT_API_HOST=http://localhost:8433 creght dev --web=http://localhost:5173 --site_id=<project_id>/<site_id> --dir=./mysite
+```
+
+The command prints the online Web editor URL, pushes local file changes to
+Cregh, and listens to the existing WebSocket collaboration channel so editor
+changes are written back to the local directory. MVP conflict handling is last
+write wins.
+
+`dev` also starts a local Vite preview by default:
+
+```text
+  VITE v8.0.14  ready in 529 ms
+  ➜  Local:   http://localhost:5173/
+Local Vite:  started (preferred http://localhost:5173; use the Vite Local URL above)
+```
+
+Use `--preview-port` or `--preview-host` to change the preferred local preview
+address. If that port is occupied, Vite uses its normal auto-port behavior and
+prints the actual URL in the terminal:
+
+```bash
+creght dev --site_id=<project_id>/<site_id> --dir=./mysite --preview-port=5174
+```
+
+Disable the local preview when you only want file sync:
+
+```bash
+creght dev --site_id=<project_id>/<site_id> --dir=./mysite --no-preview
+```
+
+The preview uses the bundled `creght-cli/vite` plugin. If the site directory
+has `node_modules/.bin/vite`, that local Vite is used; otherwise the CLI starts
+a hidden temporary Vite runtime under `.creght/` and installs `vite` plus
+`esbuild` there.
+
+Local file changes are pushed through Vite HMR as a React root re-render. This
+avoids a browser-level refresh, but it is not yet full React Fast Refresh and
+does not guarantee component state preservation.
+
+## Open Preview
+
+Open the remote preview URL for a site in the browser:
+
+```bash
+creght preview --site_id=<project_id>/<site_id>
+```
+
+For local development:
+
+```bash
+CREGHT_API_HOST=http://localhost:8433 creght preview --site_id=<project_id>/<site_id>
+```
+
+## Publish Site
+
+Publish a site:
+
+```bash
+creght publish --site_id=<project_id>/<site_id>
+```
+
+With a publish note:
+
+```bash
+creght publish --site_id=<project_id>/<site_id> --note="Update homepage copy"
+```
+
+For local development:
+
+```bash
+CREGHT_API_HOST=http://localhost:8433 creght publish --site_id=<project_id>/<site_id>
+```
+
+## Manage CMS Collections
+
+List CMS collections:
+
+```bash
+creght cms collections --site_id=<project_id>/<site_id>
+```
+
+Create a collection from a JSON Schema file:
+
+```bash
+creght cms collection create --site_id=<project_id>/<site_id> --key=blogs --name="Blogs" --schema=./blogs.schema.json
+```
+
+Update or delete by collection key or id:
+
+```bash
+creght cms collection get --site_id=<project_id>/<site_id> --key=blogs
+creght cms collection update --site_id=<project_id>/<site_id> --key=blogs --schema=./blogs.schema.json
+creght cms collection delete --site_id=<project_id>/<site_id> --key=blogs
+```
+
+`--schema` can point to either a raw JSON Schema object or a full collection JSON object containing fields such as `key`, `name`, `desc`, and `json_schema`.
+
+## Manage CMS Content
+
+List, get, create, update, and delete content entries:
+
+```bash
+creght content list --site_id=<project_id>/<site_id> --collection=blogs
+creght content get --site_id=<project_id>/<site_id> --collection=blogs --slug=hello-world
+creght content create --site_id=<project_id>/<site_id> --collection=blogs --data=./content.json --slug=hello-world
+creght content update --site_id=<project_id>/<site_id> --collection=blogs --id=<content_id> --data=./content.json
+creght content delete --site_id=<project_id>/<site_id> --collection=blogs --id=<content_id>
+```
+
+`--data` can point to either a plain CMS content body or a full content object. A plain content body may include a business field named `body`. The CLI treats JSON as a full content object only when it includes wrapper fields such as `id`, `slug`, `content_app_id`, `json_schema`, `status`, `sort`, or `tags`.
+
+If your business JSON has a top-level `slug`, do not pass it as plain body JSON because `slug` is a content wrapper field. Either pass the slug as a flag and omit it from `--data`:
+
+```bash
+creght content create --site_id=<project_id>/<site_id> --collection=prompts --data=./content-body.json --slug=typography-v02
+```
+
+Or use a full content object and put business fields under `body`:
+
+```json
+{
+  "slug": "typography-v02",
+  "body": {
+    "title": "Typography V.02",
+    "description": "100vh",
+    "tags": ["skill"]
+  }
+}
+```
+
+## Manage Forms
+
+List, create, update, and delete forms:
+
+```bash
+creght form list --site_id=<project_id>/<site_id>
+creght form create --site_id=<project_id>/<site_id> --key=contact-form --name="Contact form" --schema=./contact.schema.json
+creght form get --site_id=<project_id>/<site_id> --key=contact-form
+creght form update --site_id=<project_id>/<site_id> --key=contact-form --schema=./contact.schema.json
+creght form delete --site_id=<project_id>/<site_id> --key=contact-form
+```
+
+Inspect and delete form submissions:
+
+```bash
+creght form logs --site_id=<project_id>/<site_id> --key=contact-form
+creght form log get --site_id=<project_id>/<site_id> --key=contact-form --log_id=<log_id>
+creght form log delete --site_id=<project_id>/<site_id> --key=contact-form --log_id=<log_id>
+```
+
+Submit a form payload through the platform API:
+
+```bash
+creght form submit --site_id=<project_id>/<site_id> --key=contact-form --data=./payload.json
+```
+
+After creating or changing CMS collections or forms, run `creght pull` again to refresh generated files such as `/types/cms.d.ts` and `/types/form.d.ts` before writing code that imports those types.
+
+## Upload Assets
+
+Upload a local file through the Cregh site asset flow:
+
+```bash
+creght upload --site_id=<project_id>/<site_id> --file=./image.png
+```
+
+The command prints the public file URL by default. Use `--json` to inspect the
+full upload metadata, including `site_path`, a stable `/_assets/...` path that
+can be used from Cregh site code:
+
+```bash
+creght upload --site_id=<project_id>/<site_id> --file=./image.png --json
+```
+
+Optional flags:
+
+```bash
+creght upload --site_id=<project_id>/<site_id> --file=./image.png --name=hero.png --mimetype=image/png
+```
+
+## Push And Sync Boundary
+
+The current MVP push/sync mode is one-way:
+
+```text
+local directory -> Cregh remote site
+```
+
+`push` fetches the remote file list to build the local path to remote file id
+mapping, scans the local directory, uploads the current local snapshot, and then
+exits.
+
+`sync` is watch mode. It performs the same initial local snapshot push, then
+keeps running and automatically listens for later local changes.
+
+Neither command pulls Web editor changes back to the local directory while
+running. If you edit the same site in the Web editor, run `pull` manually or
+restart from a clean local copy before continuing.
+
+Use a test project/site while validating the CLI. Do not run `push` or `sync`
+against production content unless the local directory is intended to be the
+source of truth.
+
+## Commands
+
+Cregh CLI is a local bridge for Cregh site code. It can authenticate with
+Cregh, list projects and sites, pull remote site files into a local directory,
+push local files back to Cregh, watch local files for realtime sync, open the
+remote preview, and publish a site.
+
+The CLI commands still use the Cregh backend and web app for the canonical
+preview. The Vite plugin is a local development helper and intentionally does
+not implement full production SSR.
+
+```bash
+creght login [--web=https://creght.cn]
+creght logout
+creght project list
+creght pull --site_id=<project_id>/<site_id> --dir=./mysite
+creght push --site_id=<project_id>/<site_id> --dir=./mysite
+creght sync --site_id=<project_id>/<site_id> --dir=./mysite
+creght dev --site_id=<project_id>/<site_id> --dir=./mysite [--web=https://creght.cn]
+creght preview --site_id=<project_id>/<site_id>
+creght publish --site_id=<project_id>/<site_id> [--note=<note>]
+creght cms collections --site_id=<project_id>/<site_id>
+creght cms collection create --site_id=<project_id>/<site_id> --key=<key> --name=<name> --schema=./schema.json
+creght content list --site_id=<project_id>/<site_id> --collection=<key>
+creght content create --site_id=<project_id>/<site_id> --collection=<key> --data=./content.json
+creght form list --site_id=<project_id>/<site_id>
+creght form create --site_id=<project_id>/<site_id> --key=<key> --name=<name> --schema=./schema.json
+creght upload --site_id=<project_id>/<site_id> --file=./image.png
+creght version
+```
+
+Command meanings:
+
+- `login`: Authenticate this machine with Cregh and save a CLI token.
+- `logout`: Remove the saved CLI token and API host configuration.
+- `project`: List available projects and sites. Use `project_id/site_id` with site commands. Also supports `project create`.
+- `pull`: Download the current remote site files into a local directory.
+- `push`: Push the current local directory snapshot to the remote site.
+- `sync`: Watch mode; push the current snapshot, then keep listening for local changes.
+- `dev`: Bidirectionally sync local files with cloud realtime files and the online Web editor.
+- `preview`: Open the remote preview URL for a site in the browser.
+- `publish`: Publish a site to make the current remote site version live.
+- `cms`: Manage CMS collections.
+- `content`: Manage CMS content entries.
+- `form`: Manage forms and form submissions.
+- `upload`: Upload a local file as a Cregh site asset and print its URL.
+- `version`: Print the installed CLI version.
+
+## Release
+
+GitHub Releases are created by GitHub Actions when a tag matching `v*` is pushed.
+The same workflow publishes the npm package `creght-cli`.
+
+The release workflow builds binaries for:
+
+- macOS: `darwin/amd64`, `darwin/arm64`
+- Linux: `linux/amd64`, `linux/arm64`
+- Windows: `windows/amd64`, `windows/arm64`
+
+Create and push a release tag:
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+Before pushing a release tag, make sure `package.json` has the same version as the
+tag without the leading `v`, and configure npm Trusted Publishing for `creght-cli`
+with GitHub repository `creght/creght-cli` and workflow filename `release.yml`.
+
+If this repository is mirrored to GitHub with a different remote name, push the tag to that remote:
+
+```bash
+git remote add github git@github.com:creght-dev/creght-cli.git
+git push github main
+git push github v0.1.0
+```

package/bin/creght.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require("node:child_process");
+const path = require("node:path");
+
+const platform = process.platform;
+const arch = process.arch;
+const exe = process.platform === "win32" ? "creght.exe" : "creght";
+const binary = path.join(__dirname, "..", "vendor", `${platform}-${arch}`, exe);
+
+const result = spawnSync(binary, process.argv.slice(2), {
+  stdio: "inherit",
+});
+
+if (result.error) {
+  if (result.error.code === "ENOENT") {
+    console.error(
+      "Cregh CLI binary is missing. Reinstall creght-cli and try again.",
+    );
+  } else {
+    console.error(result.error.message);
+  }
+  process.exit(1);
+}
+
+if (typeof result.status === "number") {
+  process.exit(result.status);
+}
+
+process.exit(result.signal ? 1 : 0);

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "creght-cli",
+  "version": "0.1.16",
+  "description": "Cregh CLI for syncing local site code with Cregh.",
+  "license": "MIT",
+  "homepage": "https://github.com/creght-dev/creght-cli#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/creght-dev/creght-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/creght-dev/creght-cli/issues"
+  },
+  "bin": {
+    "creght": "bin/creght.js"
+  },
+  "exports": {
+    "./vite": {
+      "types": "./vite/index.d.ts",
+      "import": "./vite/index.js"
+    }
+  },
+  "scripts": {
+    "prepare:npm-binaries": "node scripts/prepare-npm-binaries.js",
+    "test:npm": "node scripts/install.js --check"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "vite/",
+    "vendor/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "esbuild": ">=0.20",
+    "vite": ">=5"
+  },
+  "peerDependenciesMeta": {
+    "esbuild": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    }
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ]
+}

package/scripts/install.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const packageRoot = path.join(__dirname, "..");
+const platform = process.platform;
+const arch = process.arch;
+const exe = platform === "win32" ? "creght.exe" : "creght";
+const binary = path.join(packageRoot, "vendor", `${platform}-${arch}`, exe);
+const checkOnly = process.argv.includes("--check");
+
+if (checkOnly) {
+  const exists = fs.existsSync(binary);
+  console.log(`Cregh CLI binary path for this platform: ${binary}`);
+  if (!exists) {
+    console.log("Binary is not present in this local checkout. CI adds release binaries before npm publish.");
+  }
+  process.exit(0);
+}
+
+if (!fs.existsSync(binary)) {
+  console.error(
+    `Cregh CLI binary is missing for ${platform}-${arch}. Reinstall creght-cli and try again.`,
+  );
+  process.exit(1);
+}

package/scripts/prepare-npm-binaries.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const packageRoot = path.join(__dirname, "..");
+const distDir = path.join(packageRoot, "dist");
+const vendorDir = path.join(packageRoot, "vendor");
+const version = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8")).version;
+
+const targets = [
+  { goos: "darwin", goarch: "amd64", npm: "darwin-x64", ext: "tar.gz", exe: "creght" },
+  { goos: "darwin", goarch: "arm64", npm: "darwin-arm64", ext: "tar.gz", exe: "creght" },
+  { goos: "linux", goarch: "amd64", npm: "linux-x64", ext: "tar.gz", exe: "creght" },
+  { goos: "linux", goarch: "arm64", npm: "linux-arm64", ext: "tar.gz", exe: "creght" },
+  { goos: "windows", goarch: "amd64", npm: "win32-x64", ext: "zip", exe: "creght.exe" },
+  { goos: "windows", goarch: "arm64", npm: "win32-arm64", ext: "zip", exe: "creght.exe" },
+];
+
+fs.rmSync(vendorDir, { recursive: true, force: true });
+fs.mkdirSync(vendorDir, { recursive: true });
+
+for (const target of targets) {
+  const archive = path.join(distDir, `creght_${version}_${target.goos}_${target.goarch}.${target.ext}`);
+  if (!fs.existsSync(archive)) {
+    throw new Error(`missing release archive: ${archive}`);
+  }
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "creght-npm-"));
+  try {
+    extract(archive, tmpDir, target.ext);
+    const source = path.join(tmpDir, target.exe);
+    if (!fs.existsSync(source)) {
+      throw new Error(`archive did not contain ${target.exe}: ${archive}`);
+    }
+
+    const targetDir = path.join(vendorDir, target.npm);
+    fs.mkdirSync(targetDir, { recursive: true });
+    const destination = path.join(targetDir, target.exe);
+    fs.copyFileSync(source, destination);
+    if (target.exe === "creght") {
+      fs.chmodSync(destination, 0o755);
+    }
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+function extract(archive, destination, ext) {
+  const command = ext === "zip" ? "unzip" : "tar";
+  const args = ext === "zip" ? ["-q", archive, "-d", destination] : ["-xzf", archive, "-C", destination];
+  const result = spawnSync(command, args, { stdio: "inherit" });
+
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(`${command} exited with status ${result.status}`);
+  }
+}

package/vite/import-map.js

@@ -0,0 +1,55 @@
+function mergeExternalDeps(externalValue, requiredDeps) {
+  try {
+    externalValue = decodeURIComponent(externalValue)
+  } catch {
+    // Keep the original value and continue merging invalid encoded external lists.
+  }
+
+  const seen = new Set()
+  const deps = externalValue
+    .split(',')
+    .map((dep) => dep.trim())
+    .filter(Boolean)
+    .filter((dep) => {
+      if (seen.has(dep)) return false
+      seen.add(dep)
+      return true
+    })
+
+  for (const dep of requiredDeps) {
+    if (seen.has(dep)) continue
+    seen.add(dep)
+    deps.push(dep)
+  }
+
+  return deps.join(',')
+}
+
+export function normalizeImportMapExternal(specifier, url) {
+  if (!/^https?:\/\//i.test(url)) return url
+  if (
+    specifier === 'react' ||
+    specifier.startsWith('react/') ||
+    specifier === 'react-dom' ||
+    specifier.startsWith('react-dom/')
+  ) {
+    return url
+  }
+
+  const requiredDeps = ['react', 'react-dom']
+  const hashIndex = url.indexOf('#')
+  const beforeHash = hashIndex >= 0 ? url.slice(0, hashIndex) : url
+  const hash = hashIndex >= 0 ? url.slice(hashIndex) : ''
+  const hasPrefixSlash = specifier.endsWith('/') && beforeHash.endsWith('/')
+  const externalTarget = hasPrefixSlash ? beforeHash.slice(0, -1) : beforeHash
+  const externalSuffix = hasPrefixSlash ? '/' : ''
+  const externalMatch = externalTarget.match(/([?&])external=([^&#]*)/)
+
+  if (externalMatch && externalMatch.index !== undefined) {
+    const start = externalMatch.index + externalMatch[1].length + 'external='.length
+    const end = start + externalMatch[2].length
+    return `${externalTarget.slice(0, start)}${mergeExternalDeps(externalMatch[2], requiredDeps)}${externalTarget.slice(end)}${externalSuffix}${hash}`
+  }
+
+  return `${externalTarget}${hasPrefixSlash || externalTarget.includes('?') ? '&' : '?'}external=${requiredDeps.join(',')}${externalSuffix}${hash}`
+}

package/vite/index.d.ts

@@ -0,0 +1,28 @@
+import type { Plugin } from 'vite'
+
+export type CreghVitePluginOptions = {
+  /**
+   * Local Cregh project root. Defaults to Vite's root.
+   */
+  root?: string
+  /**
+   * Cregh API host used by the local /api proxy at runtime.
+   */
+  apiHost?: string
+  /**
+   * Project id for runtime CMS/form requests.
+   */
+  projectId?: string
+  /**
+   * Optional CLI auth token. When set, local /api proxy sends it as Bearer.
+   */
+  token?: string
+  /**
+   * Platform import map entries. `creght dev` fills this from server system info.
+   * Manually configured entries override the built-in fallback when no server map is provided.
+   */
+  importMap?: Record<string, string>
+}
+
+export declare function creght(options?: CreghVitePluginOptions): Plugin
+export default creght

package/vite/index.js

@@ -0,0 +1,546 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { transform as esbuildTransform } from 'esbuild'
+import { normalizeImportMapExternal } from './import-map.js'
+
+const modulePrefix = '/@creght/module'
+const assetPrefix = '/@creght/asset'
+const runtimePrefix = '/@creght/runtime'
+const pageExts = ['.tsx', '.ts', '.jsx', '.js']
+const sourceExts = new Set([...pageExts, '.css'])
+
+const fallbackImportMap = {
+  react: 'https://esm.talizen.com/react@19.2.4?dev',
+  'react/': 'https://esm.talizen.com/react@19.2.4&dev/',
+  'react-dom': 'https://esm.talizen.com/react-dom@19.2.4?dev',
+  'react-dom/': 'https://esm.talizen.com/react-dom@19.2.4&dev/',
+  'react-dom/client': 'https://esm.talizen.com/react-dom@19.2.4/client?dev',
+  'class-variance-authority': 'https://esm.talizen.com/class-variance-authority@0.7.1',
+  clsx: 'https://esm.talizen.com/clsx@2.1.1',
+  'tailwind-merge': 'https://esm.talizen.com/tailwind-merge@3.5.0',
+  '@radix-ui/react-slot': 'https://esm.talizen.com/@radix-ui/react-slot@1.2.4',
+  'lucide-react': 'https://esm.talizen.com/lucide-react@0.577.0?dev&external=react,react-dom',
+  motion: 'https://esm.talizen.com/motion@12.38.0?dev',
+  'motion/react': 'https://esm.talizen.com/motion@12.38.0/react?dev&external=react,react-dom',
+  'framer-motion': 'https://esm.talizen.com/framer-motion@12.38.0?dev&external=react,react-dom',
+  three: 'https://esm.talizen.com/three@0.167.1',
+  'three/': 'https://esm.talizen.com/three@0.167.1/',
+  '@react-three/fiber': 'https://esm.talizen.com/@react-three/fiber@9.3.0?external=react,react-dom,three',
+  '@react-three/drei': 'https://esm.talizen.com/@react-three/drei@10.7.4?external=react,react-dom,three,@react-three',
+  talizen: 'https://esm.talizen.com/talizen@0.1.4',
+  'talizen/': 'https://esm.talizen.com/talizen@0.1.4/',
+}
+
+const escapeHtml = (s) => String(s)
+  .replaceAll('&', '&')
+  .replaceAll('<', '&lt;')
+  .replaceAll('>', '&gt;')
+  .replaceAll('"', '&quot;')
+
+const jsonScript = (value) => JSON.stringify(value).replaceAll('<', '\\u003c')
+
+const transformWithEsbuild = (source, filename, options) =>
+  esbuildTransform(source, { ...options, sourcefile: filename })
+
+const isRelativeSpecifier = (specifier) =>
+  specifier.startsWith('./') || specifier.startsWith('../') || specifier.startsWith('/')
+
+const contentTypeForPath = (file) => {
+  switch (path.extname(file).toLowerCase()) {
+    case '.css':
+      return 'text/css; charset=utf-8'
+    case '.js':
+    case '.mjs':
+      return 'text/javascript; charset=utf-8'
+    case '.json':
+      return 'application/json; charset=utf-8'
+    case '.svg':
+      return 'image/svg+xml'
+    case '.png':
+      return 'image/png'
+    case '.jpg':
+    case '.jpeg':
+      return 'image/jpeg'
+    case '.gif':
+      return 'image/gif'
+    case '.webp':
+      return 'image/webp'
+    case '.woff':
+      return 'font/woff'
+    case '.woff2':
+      return 'font/woff2'
+    default:
+      return 'application/octet-stream'
+  }
+}
+
+const normalizeProjectPath = (value) => {
+  const out = path.posix.normalize('/' + value.replaceAll(path.sep, '/').replace(/^\/+/, ''))
+  if (out.startsWith('/../')) {
+    throw new Error(`unsafe Cregh path: ${value}`)
+  }
+  return out
+}
+
+async function exists(file) {
+  try {
+    await fs.access(file)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function resolveFile(projectRoot, projectPath) {
+  const clean = normalizeProjectPath(projectPath)
+  const abs = path.join(projectRoot, clean.slice(1))
+  if (await exists(abs)) return { projectPath: clean, abs }
+
+  for (const ext of pageExts) {
+    if (await exists(abs + ext)) {
+      return { projectPath: clean + ext, abs: abs + ext }
+    }
+  }
+
+  for (const ext of pageExts) {
+    const indexPath = path.join(abs, 'Index' + ext)
+    if (await exists(indexPath)) {
+      return { projectPath: normalizeProjectPath(path.posix.join(clean, 'Index' + ext)), abs: indexPath }
+    }
+  }
+
+  throw new Error(`Cregh module not found: ${projectPath}`)
+}
+
+async function readSiteConfig(projectRoot) {
+  for (const name of ['creght.config.ts', 'creght.config.js', 'talizen.config.ts', 'talizen.config.js', 'folia.config.ts', 'folia.config.js']) {
+    const abs = path.join(projectRoot, name)
+    if (!(await exists(abs))) continue
+
+    try {
+      const source = await fs.readFile(abs, 'utf8')
+      const transformed = await transformWithEsbuild(source, abs, {
+        loader: name.endsWith('.ts') ? 'ts' : 'js',
+        format: 'cjs',
+        target: 'es2020',
+      })
+      const module = { exports: {} }
+      const require = (specifier) => {
+        if (specifier === 'creght' || specifier === 'creght/config' || specifier === 'talizen' || specifier === 'talizen/config') {
+          return { defineConfig: (config) => config }
+        }
+        if (specifier.startsWith('creght/')) return {}
+        if (specifier.startsWith('talizen/')) return {}
+        throw new Error(`[creght.config] unsupported import: ${specifier}`)
+      }
+      const fn = new Function('module', 'exports', 'require', 'defineConfig', transformed.code)
+      fn(module, module.exports, require, (config) => config)
+      const value = module.exports?.default ?? module.exports
+      return value && typeof value === 'object' ? value : {}
+    } catch (err) {
+      console.warn(`[creght vite] failed to evaluate ${name}:`, err)
+      return {}
+    }
+  }
+
+  return {}
+}
+
+async function readIndexCss(projectRoot, config) {
+  if (typeof config.tailwindCss === 'string') return config.tailwindCss
+
+  const cssPath = path.join(projectRoot, 'index.css')
+  if (!(await exists(cssPath))) return ''
+  return fs.readFile(cssPath, 'utf8')
+}
+
+async function buildImportMap(projectRoot, options) {
+  const config = await readSiteConfig(projectRoot)
+  const userImports = config.importMap?.imports || {}
+  const imports = Object.keys(options.importMap || {}).length > 0
+    ? { ...options.importMap }
+    : { ...fallbackImportMap }
+
+  for (const [specifier, url] of Object.entries(userImports)) {
+    imports[specifier] = normalizeImportMapExternal(specifier, String(url))
+  }
+  for (const [specifier, url] of Object.entries(options.importMap || {})) {
+    imports[specifier] = normalizeImportMapExternal(specifier, String(url))
+  }
+
+  return { config, imports }
+}
+
+async function listPages(projectRoot) {
+  const pageRoot = path.join(projectRoot, 'page')
+  if (!(await exists(pageRoot))) return []
+
+  const out = []
+  async function walk(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true })
+    for (const entry of entries) {
+      const abs = path.join(dir, entry.name)
+      if (entry.isDirectory()) {
+        await walk(abs)
+        continue
+      }
+      const ext = path.extname(entry.name)
+      if (!pageExts.includes(ext)) continue
+      if (entry.name.includes('.canvas.')) continue
+      const rel = normalizeProjectPath(path.relative(projectRoot, abs))
+      out.push({ file: rel, route: routeFromPagePath(rel) })
+    }
+  }
+  await walk(pageRoot)
+  return out.sort((a, b) => a.route.localeCompare(b.route))
+}
+
+function routeFromPagePath(file) {
+  const withoutExt = file.replace(/^\/page\//, '').replace(/\.[^.]+$/, '')
+  if (withoutExt === 'Index') return '/'
+  return '/' + withoutExt
+    .replace(/\/Index$/, '')
+    .split('/')
+    .map((segment) => segment.startsWith('[') && segment.endsWith(']') ? `:${segment.slice(1, -1)}` : segment.toLowerCase())
+    .join('/')
+}
+
+function matchRoute(routes, pathname) {
+  const normalized = pathname !== '/' ? pathname.replace(/\/+$/, '') : '/'
+  const exact = routes.find((r) => r.route === normalized)
+  if (exact) return { ...exact, params: {} }
+
+  for (const route of routes) {
+    const routeParts = route.route.split('/').filter(Boolean)
+    const pathParts = normalized.split('/').filter(Boolean)
+    if (routeParts.length !== pathParts.length) continue
+    const params = {}
+    let ok = true
+    for (let i = 0; i < routeParts.length; i++) {
+      const part = routeParts[i]
+      if (part.startsWith(':')) {
+        params[part.slice(1)] = decodeURIComponent(pathParts[i])
+        continue
+      }
+      if (part !== pathParts[i].toLowerCase()) {
+        ok = false
+        break
+      }
+    }
+    if (ok) return { ...route, params }
+  }
+
+  return { ...(routes.find((r) => r.route === '/') || routes[0]), params: {} }
+}
+
+function rewriteModuleSpecifiers(code, importerPath) {
+  const rewrite = (specifier) => {
+    if (!isRelativeSpecifier(specifier)) return specifier
+    const [rawPath, rawQuery = ''] = specifier.split('?')
+    const importerDir = path.posix.dirname(importerPath)
+    const resolved = normalizeProjectPath(path.posix.join(importerDir, rawPath))
+    const target = rawQuery ? `${resolved}?${rawQuery}` : resolved
+    return `${modulePrefix}?path=${encodeURIComponent(target)}`
+  }
+
+  return code
+    .replace(/(from\s*["'])([^"']+)(["'])/g, (_, before, specifier, after) => `${before}${rewrite(specifier)}${after}`)
+    .replace(/(import\s*["'])([^"']+)(["'])/g, (_, before, specifier, after) => `${before}${rewrite(specifier)}${after}`)
+    .replace(/(import\s*\(\s*["'])([^"']+)(["']\s*\))/g, (_, before, specifier, after) => `${before}${rewrite(specifier)}${after}`)
+}
+
+async function transformProjectModule(projectRoot, projectPath) {
+  const [pathWithoutQuery, query = ''] = projectPath.split('?')
+  const { projectPath: resolvedProjectPath, abs } = await resolveFile(projectRoot, pathWithoutQuery)
+  const ext = path.extname(abs).toLowerCase()
+
+  if (query === 'raw') {
+    const source = await fs.readFile(abs, 'utf8')
+    return `export default ${JSON.stringify(source)};\n`
+  }
+  if (query === 'url') {
+    return `export default ${JSON.stringify(`${assetPrefix}?path=${encodeURIComponent(resolvedProjectPath)}`)};\n`
+  }
+  if (!sourceExts.has(ext)) {
+    return `export default ${JSON.stringify(`${assetPrefix}?path=${encodeURIComponent(resolvedProjectPath)}`)};\n`
+  }
+
+  const source = await fs.readFile(abs, 'utf8')
+  if (abs.endsWith('.css')) {
+    return `
+const css = ${JSON.stringify(source)};
+let style = document.querySelector('style[data-talizen-css-module="${resolvedProjectPath}"]');
+if (!style) {
+  style = document.createElement('style');
+  style.dataset.talizenCssModule = ${JSON.stringify(resolvedProjectPath)};
+  document.head.appendChild(style);
+}
+style.textContent = css;
+export default css;
+`
+  }
+
+  const loader = abs.endsWith('.tsx') ? 'tsx' : abs.endsWith('.ts') ? 'ts' : abs.endsWith('.jsx') ? 'jsx' : 'js'
+  const result = await transformWithEsbuild(source, abs, {
+    loader,
+    jsx: 'automatic',
+    jsxDev: true,
+    sourcemap: 'inline',
+    target: 'es2020',
+    define: {
+      'process.env.NODE_ENV': '"development"',
+      'process.env.RENDER_ENV': '"design"',
+      'process.env.RENDER_MODE': '"design"',
+    },
+  })
+
+  return rewriteModuleSpecifiers(result.code, resolvedProjectPath)
+}
+
+function renderRuntimeScript(entryFile, params, options) {
+  const projectId = options.projectId || ''
+  const authHeaders = options.token ? { Authorization: `Bearer ${options.token}` } : {}
+
+  return `
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import { createHotContext } from '/@vite/client';
+
+const creghtRuntimeHeaders = ${jsonScript(authHeaders)};
+const creghtRuntimeFetch = window.fetch.bind(window);
+
+window.TalizenConfig = {
+  baseUrl: window.location.origin + '/api/u/v2/project/' + ${JSON.stringify(projectId)},
+  headers: creghtRuntimeHeaders,
+  fetch(input, init = {}) {
+    const headers = new Headers(init.headers || {});
+    for (const [key, value] of Object.entries(creghtRuntimeHeaders)) {
+      if (!headers.has(key)) headers.set(key, value);
+    }
+    return creghtRuntimeFetch(input, { ...init, headers });
+  },
+};
+
+const rootEl = document.getElementById('root');
+const root = createRoot(rootEl);
+let renderVersion = 0;
+
+async function loadPageModule() {
+  return import(${JSON.stringify(`${modulePrefix}?path=${encodeURIComponent(entryFile)}`)} + '&t=' + Date.now());
+}
+
+async function renderPage() {
+  const version = ++renderVersion;
+  const pageModule = await loadPageModule();
+  if (version !== renderVersion) return;
+
+  const Page = pageModule.default || pageModule.App;
+  let props = {};
+
+  if (!Page) {
+    throw new Error('Cregh page has no default export: ${entryFile}');
+  }
+
+  if (typeof pageModule.getServerSideProps === 'function') {
+    const result = await pageModule.getServerSideProps({
+      query: Object.fromEntries(new URLSearchParams(window.location.search)),
+      params: ${jsonScript(params)},
+    });
+    props = result && result.props ? result.props : {};
+  }
+
+  root.render(React.createElement(Page, props));
+}
+
+const hot = createHotContext(${JSON.stringify(`${runtimePrefix}?entry=${encodeURIComponent(entryFile)}`)});
+
+await renderPage();
+
+hot.on('creght:update', () => {
+  renderPage().catch((err) => {
+    console.error('[creght vite] hot update failed', err);
+  });
+});
+`
+}
+
+async function renderHtml(projectRoot, pathname, options) {
+  const routes = await listPages(projectRoot)
+  if (routes.length === 0) {
+    return `<!doctype html><div style="font:14px system-ui;padding:24px">No Cregh pages found in <code>/page</code>.</div>`
+  }
+
+  const matched = matchRoute(routes, pathname)
+  const { config, imports } = await buildImportMap(projectRoot, options)
+  const indexCss = await readIndexCss(projectRoot, config)
+  const customCode = config.customCode || {}
+
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(matched.route === '/' ? 'Cregh' : matched.route)}</title>
+  <script type="importmap">${jsonScript({ imports })}</script>
+  <script type="module" src="/@vite/client"></script>
+  <style type="text/tailwindcss">${indexCss}</style>
+  <script type="module" src="https://esm.talizen.com/@tailwindcss/browser@4"></script>
+  ${customCode.head || ''}
+</head>
+<body>
+  ${customCode.bodyStart || ''}
+  <div id="root"></div>
+  <script type="module" src="${runtimePrefix}?entry=${encodeURIComponent(matched.file)}&params=${encodeURIComponent(JSON.stringify(matched.params))}&t=${Date.now()}"></script>
+  ${customCode.bodyEnd || customCode.body || ''}
+</body>
+</html>`
+}
+
+export function creght(options = {}) {
+  let projectRoot = ''
+  const apiHost = (options.apiHost || 'https://creght.cn').replace(/\/+$/, '')
+
+  return {
+    name: 'creght-local-preview',
+    enforce: 'pre',
+    configResolved(config) {
+      projectRoot = path.resolve(options.root || config.root)
+    },
+    configureServer(server) {
+      const hmrTimers = new Map()
+      const sendCreghUpdate = (file) => {
+        if (!file.startsWith(projectRoot)) return
+
+        const projectPath = normalizeProjectPath(path.relative(projectRoot, file))
+        const existing = hmrTimers.get(projectPath)
+        if (existing) clearTimeout(existing)
+
+        hmrTimers.set(projectPath, setTimeout(() => {
+          hmrTimers.delete(projectPath)
+          server.ws.send({
+            type: 'custom',
+            event: 'creght:update',
+            data: {
+              file: projectPath,
+              time: Date.now(),
+            },
+          })
+        }, 80))
+      }
+
+      server.watcher.add(path.join(projectRoot, '**/*'))
+      server.watcher.on('change', sendCreghUpdate)
+      server.watcher.on('add', sendCreghUpdate)
+      server.watcher.on('unlink', sendCreghUpdate)
+
+      server.middlewares.use(async (req, res, next) => {
+        try {
+          const url = new URL(req.url || '/', 'http://localhost')
+
+          if (url.pathname.startsWith('/api/')) {
+            const headers = new Headers()
+            for (const [key, value] of Object.entries(req.headers)) {
+              if (Array.isArray(value)) {
+                headers.set(key, value.join(', '))
+              } else if (value != null) {
+                headers.set(key, value)
+              }
+            }
+            headers.set('host', new URL(apiHost).host)
+            if (options.token) {
+              headers.delete('cookie')
+              headers.set('authorization', `Bearer ${options.token}`)
+            }
+
+            const method = req.method || 'GET'
+            const body = method === 'GET' || method === 'HEAD' ? undefined : req
+            const upstream = await fetch(apiHost + url.pathname + url.search, {
+              method,
+              headers,
+              body,
+              // Required by Node fetch when the request body is a stream.
+              duplex: body ? 'half' : undefined,
+            })
+
+            res.statusCode = upstream.status
+            upstream.headers.forEach((value, key) => {
+              const lowerKey = key.toLowerCase()
+              if (lowerKey === 'content-encoding') return
+              if (lowerKey === 'content-length') return
+              if (lowerKey === 'transfer-encoding') return
+              if (lowerKey === 'connection') return
+              res.setHeader(key, value)
+            })
+            const data = Buffer.from(await upstream.arrayBuffer())
+            res.end(data)
+            return
+          }
+
+          if (url.pathname === modulePrefix) {
+            const projectPath = url.searchParams.get('path')
+            if (!projectPath) {
+              res.statusCode = 400
+              res.end('missing path')
+              return
+            }
+            const code = await transformProjectModule(projectRoot, projectPath)
+            res.setHeader('Content-Type', 'text/javascript; charset=utf-8')
+            res.end(code)
+            return
+          }
+
+          if (url.pathname === runtimePrefix) {
+            const entry = url.searchParams.get('entry')
+            const rawParams = url.searchParams.get('params') || '{}'
+            if (!entry) {
+              res.statusCode = 400
+              res.end('missing entry')
+              return
+            }
+            let params = {}
+            try {
+              params = JSON.parse(rawParams)
+            } catch {
+              params = {}
+            }
+            res.setHeader('Content-Type', 'text/javascript; charset=utf-8')
+            res.end(renderRuntimeScript(entry, params, options))
+            return
+          }
+
+          if (url.pathname === assetPrefix) {
+            const projectPath = url.searchParams.get('path')
+            if (!projectPath) {
+              res.statusCode = 400
+              res.end('missing path')
+              return
+            }
+            const { abs } = await resolveFile(projectRoot, projectPath)
+            res.setHeader('Content-Type', contentTypeForPath(abs))
+            res.end(await fs.readFile(abs))
+            return
+          }
+
+          if (req.method !== 'GET') {
+            next()
+            return
+          }
+
+          const accept = req.headers.accept || ''
+          if (!accept.includes('text/html')) {
+            next()
+            return
+          }
+
+          const html = await renderHtml(projectRoot, url.pathname, options)
+          res.setHeader('Content-Type', 'text/html; charset=utf-8')
+          res.end(html)
+        } catch (err) {
+          next(err)
+        }
+      })
+    },
+  }
+}
+
+export default creght

package/vite/index.test.mjs

@@ -0,0 +1,47 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { normalizeImportMapExternal } from './import-map.js'
+
+describe('normalizeImportMapExternal', () => {
+  it('adds react and react-dom externals to regular import map entries', () => {
+    assert.equal(
+      normalizeImportMapExternal('framer-motion', 'https://esm.talizen.com/framer-motion'),
+      'https://esm.talizen.com/framer-motion?external=react,react-dom',
+    )
+  })
+
+  it('merges missing externals without dropping existing entries', () => {
+    assert.equal(
+      normalizeImportMapExternal(
+        '@react-three/drei',
+        'https://esm.talizen.com/@react-three/drei?external=three,react,@react-three/fiber',
+      ),
+      'https://esm.talizen.com/@react-three/drei?external=three,react,@react-three/fiber,react-dom',
+    )
+  })
+
+  it('inserts externals before the trailing slash for prefix import map entries', () => {
+    assert.equal(
+      normalizeImportMapExternal('talizen/', 'https://esm.talizen.com/talizen@0.1.4/'),
+      'https://esm.talizen.com/talizen@0.1.4&external=react,react-dom/',
+    )
+  })
+
+  it('merges externals before the trailing slash for prefix entries', () => {
+    assert.equal(
+      normalizeImportMapExternal(
+        '@kobalte/core/',
+        'https://esm.talizen.com/@kobalte/core&external=react/',
+      ),
+      'https://esm.talizen.com/@kobalte/core&external=react,react-dom/',
+    )
+  })
+
+  it('does not modify host React runtime specifiers', () => {
+    assert.equal(
+      normalizeImportMapExternal('react-dom/client', 'https://esm.talizen.com/react-dom@19/client?dev'),
+      'https://esm.talizen.com/react-dom@19/client?dev',
+    )
+  })
+})

package/vite/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}