@gogitcms/editor 0.23.0

package/app/vendor/realtime/src/hooks.ts

@@ -0,0 +1,57 @@
+import { useEffect, useRef, useState } from "react";
+import { createDocCollab, type DocCollab, type CollabUser } from "./collab";
+
+export type UseDocCollabOptions = {
+  // Base WebSocket URL, e.g. "wss://host/collab/ws". When empty/undefined the
+  // hook stays inert (returns null) — collaboration is simply off.
+  wsBase?: string;
+  room: string;
+  user: CollabUser | null | undefined;
+  getToken: () => string;
+};
+
+// useDocCollab owns one DocCollab for a document, recreating it when the room
+// changes and destroying it on unmount. Returns null while inputs are missing.
+export function useDocCollab(opts: UseDocCollabOptions): DocCollab | null {
+  const { wsBase, room, user } = opts;
+  // Keep the latest token getter without forcing recreation of the connection.
+  const getToken = useRef(opts.getToken);
+  getToken.current = opts.getToken;
+
+  const [collab, setCollab] = useState<DocCollab | null>(null);
+  const enabled = !!wsBase && !!room && !!user;
+
+  useEffect(() => {
+    // Visible diagnostic: shows whether a session is being created and why not.
+    console.log(`[collab] useDocCollab room=${room} enabled=${enabled}`, {
+      wsBase,
+      hasUser: !!user,
+    });
+    if (!enabled) {
+      setCollab(null);
+      return;
+    }
+    let instance: DocCollab;
+    try {
+      instance = createDocCollab({
+        wsBase: wsBase!,
+        room,
+        user: user!,
+        getToken: () => getToken.current(),
+      });
+    } catch (err) {
+      console.error(`[collab] failed to start session for room=${room}`, err);
+      setCollab(null);
+      return;
+    }
+    setCollab(instance);
+    return () => {
+      instance.destroy();
+      setCollab(null);
+    };
+    // user identity is stable per session; recreate only on connection identity.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [enabled, wsBase, room]);
+
+  return collab;
+}

package/app/vendor/realtime/src/index.ts

@@ -0,0 +1,12 @@
+// Public API for @gogitcms/realtime — the collaborative-editing (Yjs) client.
+export { createDocCollab, colorForId } from "./collab";
+export type {
+  DocCollab,
+  CollabText,
+  CollabPeer,
+  CollabUser,
+  CollabStatus,
+  CreateDocCollabOptions,
+} from "./collab";
+export { useDocCollab } from "./hooks";
+export type { UseDocCollabOptions } from "./hooks";

package/app/vendor/realtime/src/pure.ts

@@ -0,0 +1,43 @@
+// Pure, dependency-free helpers (no yjs), so they can be unit-tested in isolation.
+
+// colorForId derives a deterministic, pleasant color from a stable id (e.g. a
+// user id), so a given user shows the same presence color everywhere without
+// server coordination.
+export function colorForId(id: string): string {
+  let h = 0;
+  for (let i = 0; i < id.length; i++) h = (h * 31 + id.charCodeAt(i)) >>> 0;
+  const hue = h % 360;
+  return `hsl(${hue} 70% 45%)`;
+}
+
+// computeSplice returns the minimal single edit (delete a middle run, insert a
+// middle run) that turns `cur` into `next`, preserving the shared prefix and
+// suffix. Applying only the changed middle to a Y.Text lets concurrent remote
+// edits outside that range survive, instead of replacing the whole value.
+export function computeSplice(
+  cur: string,
+  next: string,
+): { index: number; deleteCount: number; insert: string } {
+  const start = commonPrefix(cur, next);
+  const suffix = commonSuffix(cur, next, start);
+  const endCur = cur.length - suffix;
+  const endNext = next.length - suffix;
+  return { index: start, deleteCount: Math.max(0, endCur - start), insert: next.slice(start, endNext) };
+}
+
+// commonPrefix returns the length of the shared leading run of a and b.
+function commonPrefix(a: string, b: string): number {
+  const n = Math.min(a.length, b.length);
+  let i = 0;
+  while (i < n && a[i] === b[i]) i++;
+  return i;
+}
+
+// commonSuffix returns the length of the shared trailing run of a and b, not
+// overlapping the first `floor` characters already matched as a prefix.
+function commonSuffix(a: string, b: string, floor: number): number {
+  const max = Math.min(a.length, b.length) - floor;
+  let i = 0;
+  while (i < max && a[a.length - 1 - i] === b[b.length - 1 - i]) i++;
+  return i;
+}

package/app/vite.config.mjs

@@ -0,0 +1,59 @@
+// Generated by scripts/prepack.mjs — do not edit.
+// Mirrors apps/frontend/vite.config.ts, with the workspace @gogitcms/* packages
+// resolved to the copies vendored alongside this file.
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const vendor = (name) => path.join(here, "vendor", name, "src", "index.ts");
+
+// The staged main.tsx boots plugins from virtual:cms-plugins. gogitcms-editor's dev
+// and build commands provide the real module (from the project's cms.config.js
+// `plugins`) as an `enforce: "pre"` inline plugin, which resolves the id
+// before this one. This fallback only supplies an empty list for a bare
+// `vite build` on the staged app (e.g. the smoke test), so that still compiles.
+const emptyCmsPlugins = {
+  name: "cms-plugins-empty",
+  resolveId(id) {
+    return id === "virtual:cms-plugins" ? "\0virtual:cms-plugins" : undefined;
+  },
+  load(id) {
+    return id === "\0virtual:cms-plugins" ? "export const plugins = [];\n" : undefined;
+  },
+};
+
+export default defineConfig({
+  plugins: [react(), emptyCmsPlugins],
+  define: { global: "window", __DEV__: JSON.stringify(false) },
+  resolve: {
+    alias: {
+      "react-native": "react-native-web",
+      "@gogitcms/analytics": vendor("analytics"),
+      "@gogitcms/design-system": vendor("design-system"),
+      "@gogitcms/markdown-editor": vendor("markdown-editor"),
+      "@gogitcms/plugin-sdk": vendor("plugin-sdk"),
+      "@gogitcms/realtime": vendor("realtime"),
+    },
+    extensions: [".web.tsx", ".web.ts", ".tsx", ".ts", ".js"],
+  },
+  optimizeDeps: {
+    // Force these CJS-in-an-ESM-world packages to be pre-bundled, so Vite never
+    // serves them raw (a raw CJS module references `module`/`exports`, which
+    // don't exist in the browser — "module is not defined").
+    //   * @react-navigation/native: type:commonjs with an ESM-syntax main; when
+    //     served raw its CJS leaf use-latest-callback breaks default interop.
+    //   * @apollo/client + rehackt: Apollo's React shim `rehackt` is CJS, and
+    //     whether Vite folds it into the Apollo chunk or serves it standalone
+    //     varies by install/discovery order; force both so it is always bundled.
+    include: ["@react-navigation/native", "@apollo/client", "@apollo/client > rehackt"],
+    // Web variants must lead here too: the esbuild pre-bundler resolves imports
+    // with this list (not resolve.extensions above), so without .web.tsx/.web.ts
+    // it would scan native-only files like Icon.tsx and try to pull in
+    // react-native-svg, which the web build never actually loads.
+    esbuildOptions: {
+      resolveExtensions: [".web.tsx", ".web.ts", ".web.js", ".js", ".ts", ".tsx"],
+    },
+  },
+});

package/bin/gogitcms-editor.mjs

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+// gogitcms-editor — terminal UI for setting up and running the Go·Git CMS editor.
+//
+// Subcommands map one-to-one onto the steps of the onboarding design. Running it
+// bare prints the help.
+
+import { Screen } from "../src/tui/screen.mjs";
+import { NotInteractiveError } from "../src/tui/prompts.mjs";
+import { login } from "../src/commands/login.mjs";
+import { init } from "../src/commands/init.mjs";
+import { dev } from "../src/commands/dev.mjs";
+import { build } from "../src/commands/build.mjs";
+import { logout, nextHint, status } from "../src/commands/status.mjs";
+import * as config from "../src/lib/config.mjs";
+import * as credentials from "../src/lib/credentials.mjs";
+
+// Flags shared by every command, plus the few that are command-specific. Values
+// are strings unless listed as boolean.
+const BOOLEAN_FLAGS = new Set(["open", "yes", "help", "version", "no-tty", "local"]);
+const ALIASES = { p: "port", o: "out", h: "help", y: "yes", v: "version" };
+
+function parseArgs(argv) {
+  const opts = {};
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("-")) {
+      rest.push(arg);
+      continue;
+    }
+    const [flag, inline] = arg.replace(/^--?/, "").split("=");
+    const name = ALIASES[flag] || flag;
+    if (BOOLEAN_FLAGS.has(name)) {
+      opts[camel(name)] = true;
+      continue;
+    }
+    opts[camel(name)] = inline ?? argv[++i];
+  }
+  return { opts, rest };
+}
+
+const camel = (s) => s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+
+const COMMANDS = { login, init, dev, build, status, logout };
+
+const HELP = `
+gogitcms-editor — set up and run the Go·Git CMS editor
+
+  gogitcms-editor login           authenticate this machine
+  gogitcms-editor init            create cms.config.mjs for this project
+  gogitcms-editor dev             start the local editor
+  gogitcms-editor build           export the static editor to ./dist
+  gogitcms-editor status          show setup progress
+  gogitcms-editor logout          forget this machine's stored session
+
+Options
+  --local                    edit the files in this directory, with no account
+                             or server (dev only; runs the bundled gitcms-local
+                             binary from the platform optional dependency)
+  --root <dir>               working copy to serve in --local mode (default .)
+  --local-port <port>        port for the local content server in --local mode
+                             (default 4321)
+  --api-url <url>            CMS server to talk to (env GITCMS_API_URL)
+  --workspace <id|slug>      workspace for init, when not choosing interactively
+  --repository <id|owner/name>  repository for init
+  -y, --yes                  don't ask before overwriting an existing config
+  -p, --port <port>          dev server port (default 5173)
+  --host <host>              dev server bind address (default localhost)
+  --open                     open the browser once dev is ready
+  -o, --out <dir>            build output directory (default dist)
+  --base <path>              path the editor is served from, overriding the
+                             config's BASE_PATH (e.g. /cms/); applies to
+                             init, dev and build
+  --no-tty                   plain output, no menus or animation
+  -h, --help                 show this help
+`;
+
+async function main() {
+  const { opts, rest } = parseArgs(process.argv.slice(2));
+  if (opts.noTty) process.env.GITCMS_NO_TTY = "1";
+
+  if (opts.version) {
+    const { default: pkg } = await import("../package.json", { with: { type: "json" } });
+    console.log(pkg.version);
+    return 0;
+  }
+  // No command is not an error, but there is nothing to guess at either: show
+  // what the CLI can do and let the user pick.
+  const name = rest[0];
+  if (!name || opts.help || name === "help") {
+    console.log(HELP.trim());
+    return 0;
+  }
+  if (!COMMANDS[name]) {
+    console.error(`Unknown command: ${name}\nRun  gogitcms-editor help  for the list.`);
+    return 1;
+  }
+
+  const screen = new Screen();
+  // Seed the status line from what is already on disk, so the very first frame
+  // reports the real state instead of a default that flips a moment later.
+  await primeStatus(screen, opts);
+
+  // Ctrl-C anywhere outside a prompt (the long device-code poll, a running dev
+  // server) lands here. Without it the process dies mid-frame, leaving the
+  // status bar drawn and the terminal's colours unreset. A command that owns
+  // something closable claims the signal via screen.onInterrupt and returns
+  // normally instead, so the finally below still restores the terminal.
+  const onSignal = () => {
+    if (screen.onInterrupt) {
+      const claimed = screen.onInterrupt;
+      screen.onInterrupt = null;
+      void claimed();
+      return;
+    }
+    screen.finish();
+    process.exit(130);
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+
+  try {
+    return await COMMANDS[name](screen, opts);
+  } catch (e) {
+    screen.stopSpinner();
+    if (e instanceof NotInteractiveError) {
+      screen.fail(e.message);
+      return 1;
+    }
+    screen.fail(e?.message || String(e));
+    if (process.env.GITCMS_DEBUG) console.error(e);
+    return 1;
+  } finally {
+    screen.finish();
+    // These outlive the command otherwise, and a listener on the process keeps
+    // nothing alive but does keep firing.
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+  }
+}
+
+async function primeStatus(screen, opts) {
+  try {
+    const cfg = await config.load();
+    // Local mode has no account, so the sign-in step is satisfied by definition —
+    // showing "not logged in" would be reporting a blocker that doesn't exist.
+    if (opts.local || cfg?.MODE === "local") {
+      screen.setDone(0, true);
+      screen.setDone(1, Boolean(cfg));
+      screen.setStatus({ auth: "local files", authed: true, hint: "run  gogitcms-editor dev --local" });
+      return;
+    }
+    const apiUrl = opts.apiUrl || cfg?.API_URL;
+    const creds = apiUrl ? await credentials.load(apiUrl) : (await credentials.loadAny())?.[1];
+    const done = [Boolean(creds), Boolean(cfg), false];
+    done.forEach((d, i) => screen.setDone(i, d));
+    screen.setStatus({
+      auth: creds?.email || "not logged in",
+      authed: Boolean(creds),
+      hint: nextHint(done),
+    });
+  } catch {
+    // A malformed config must not stop the CLI from running — the command that
+    // needs it will report the problem in context.
+  }
+}
+
+process.exitCode = await main();