@open-press/cli 0.7.1 → 1.0.0

package/template/core/engine/runtime/validation.mjs

@@ -17,6 +17,20 @@ const PUBLIC_DEPLOY_ADAPTERS = new Set([
   "vercel",
 ]);
 
+// A directory is an OpenPress workspace if it contains a
+// press/index.tsx entry, or a package.json with an "openpress" field.
+async function isWorkspaceRoot(dir) {
+  try {
+    await fs.access(path.join(dir, "press", "index.tsx"));
+    return true;
+  } catch {}
+  try {
+    const pkg = JSON.parse(await fs.readFile(path.join(dir, "package.json"), "utf8"));
+    if (pkg?.openpress && typeof pkg.openpress === "object") return true;
+  } catch {}
+  return false;
+}
+
 export async function discoverWorkspace(startPath = ".") {
   let current = path.resolve(startPath);
   try {
@@ -26,15 +40,10 @@ export async function discoverWorkspace(startPath = ".") {
     current = path.dirname(current);
   }
   while (true) {
-    const configPath = path.join(current, "openpress.config.mjs");
-    try {
-      await fs.access(configPath);
-      return current;
-    } catch {
-      const parent = path.dirname(current);
-      if (parent === current) throw new Error(`No OpenPress workspace found from ${startPath}`);
-      current = parent;
-    }
+    if (await isWorkspaceRoot(current)) return current;
+    const parent = path.dirname(current);
+    if (parent === current) throw new Error(`No OpenPress workspace found from ${startPath}`);
+    current = parent;
   }
 }
 
@@ -78,7 +87,7 @@ export async function validateWorkspace(root) {
 
   mark(sourceWorkspace.checkedName);
   if (!(typeof activeConfig.title === "string" && activeConfig.title.trim())) {
-    add("warning", "config.title", "openpress.config.mjs `title` is empty; the workbench will show the default placeholder.", activeConfig.configPath);
+    add("warning", "press.title", "<Press title> is missing in press/index.tsx; the workbench will show the default placeholder.", activeConfig.configPath);
   }
   if (!(await sourceDirectoryExists(sourceWorkspace))) {
     add("warning", sourceWorkspace.missingCode, sourceWorkspace.missingMessage, sourceWorkspace.sourceDir);

package/template/core/openpress.config.mjs

@@ -1,10 +1,6 @@
-// Root pointer. The real workspace config lives at document/openpress.config.mjs.
-//
-// document/ is git-ignored in this framework checkout. Populate it locally
-// from a style pack's React/MDX document starter:
-//   cp -R skills/editorial-monograph/starter/document/. document/
-// Or create a separate workspace:
-//   node engine/cli.mjs init ../my-openpress-document
+// Legacy root pointer kept for older local workspaces. Current OpenPress
+// workspaces use package.json "openpress" config plus a press/ source tree.
+// Starter files are supplied by skills, not fetched by the core engine.
 
 export default {
   documentDir: "document",

package/template/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-press/core",
-  "version": "0.7.1",
+  "version": "1.0.0",
   "type": "module",
   "description": "open-press core — runtime primitives, CLI, and render pipeline for AI-first fixed-layout documents.",
   "license": "MIT",
@@ -54,17 +54,15 @@
     "test:e2e:reader": "playwright test --config playwright.reader.config.ts",
     "test:node": "node --test tests/*.test.mjs",
     "test:react": "vitest run",
-    "openpress:validate": "node engine/cli.mjs validate .",
-    "openpress:export": "node engine/cli.mjs export .",
+    "openpress:image": "node engine/cli.mjs image .",
     "openpress:pdf": "node engine/cli.mjs pdf .",
-    "openpress:render": "node engine/cli.mjs render . --renderer react",
-    "openpress:preview": "node engine/cli.mjs preview . --renderer react",
     "openpress:deploy": "node engine/cli.mjs deploy .",
     "openpress:deploy:dry-run": "node engine/cli.mjs deploy . --confirm --dry-run"
   },
   "dependencies": {
     "@mdx-js/mdx": "^3.1.1",
     "@mdx-js/react": "^3.1.1",
+    "html-to-image": "^1.11.13",
     "js-yaml": "^4.1.1",
     "katex": "^0.16.47",
     "lucide-react": "^1.16.0",

package/template/core/src/main.tsx

@@ -1,6 +1,6 @@
 import { StrictMode } from "react";
 import { createRoot } from "react-dom/client";
-import { App } from "./openpress/App";
+import { OpenPressApp } from "./openpress/app";
 import "./styles/openpress.css";
 
 const rootElement = document.getElementById("root");
@@ -11,6 +11,6 @@ if (!rootElement) {
 
 createRoot(rootElement).render(
   <StrictMode>
-    <App />
+    <OpenPressApp />
   </StrictMode>,
 );

package/template/core/src/openpress/app/OpenPressApp.tsx

@@ -0,0 +1,296 @@
+import { useCallback, useEffect, useState } from "react";
+import { OpenPressRuntime } from "./OpenPressRuntime";
+import { WorkspaceGalleryPage } from "./WorkspaceGalleryPage";
+import { isLocalWorkspaceHost } from "../shared";
+import type {
+  DeploymentInfo,
+  ReaderDocument,
+  WorkspaceManifest,
+  WorkspaceManifestPress,
+} from "../document-model";
+import { findManifestPress, manifestHasMultiplePresses } from "../document-model";
+
+type LoadState =
+  | { status: "loading" }
+  | {
+      // Gallery state — shown for multi-Press workspaces at the root URL.
+      // Single-Press workspaces never reach this state.
+      status: "gallery";
+      manifest: WorkspaceManifest;
+      deploymentInfo: DeploymentInfo;
+    }
+  | {
+      status: "ready";
+      document: ReaderDocument;
+      deploymentInfo: DeploymentInfo;
+      manifest: WorkspaceManifest | null;
+      // Empty string for single-Press workspaces (no slug routing needed)
+      // or for the root entry of a multi-Press workspace. Otherwise the
+      // active press's slug — used by refresh/back/forward to re-resolve.
+      activeSlug: string;
+    }
+  | { status: "error"; message: string };
+
+interface DeployConfig {
+  pdf?: string;
+  deployed_at?: string;
+  public_url?: string;
+  dirty?: boolean;
+  deploy_configured?: boolean;
+  deploy_adapter?: string;
+  deploy_source?: string;
+  deploy_project_name?: string | null;
+  deploy_setup_message?: string;
+}
+
+const offlineDeploymentInfo: DeploymentInfo = { online: false };
+
+function LoadingScreen() {
+  return (
+    <div className="openpress-loading-screen" aria-label="載入中" role="status">
+      <div className="openpress-loading-screen__inner">
+        <div className="openpress-loading-dots" aria-hidden="true">
+          <span /><span /><span />
+        </div>
+        <span className="openpress-loading-screen__label">載入文件</span>
+      </div>
+    </div>
+  );
+}
+
+export function OpenPressApp() {
+  const [state, setState] = useState<LoadState>({ status: "loading" });
+
+  // Single resolution function — same code path for "boot from URL",
+  // "click gallery card", and "browser back button". Given a manifest
+  // + slug, decides whether to render gallery or load a press.
+  const resolveFromSlug = useCallback(async (
+    manifest: WorkspaceManifest | null,
+    slug: string,
+    deploymentInfo: DeploymentInfo,
+  ) => {
+    // No manifest (legacy deploy): always load /openpress/document.json.
+    if (!manifest || manifest.presses.length === 0) {
+      const document = await loadReaderDocument("/openpress/document.json");
+      setState({ status: "ready", document, deploymentInfo, manifest, activeSlug: "" });
+      return;
+    }
+
+    // Empty slug + multi-Press: show gallery. Empty slug + single-Press:
+    // load the only press. Same expression handles both — array length
+    // is the only thing that matters.
+    const normalizedSlug = normalizeSlug(slug);
+    if (!normalizedSlug && manifestHasMultiplePresses(manifest)) {
+      setState({ status: "gallery", manifest, deploymentInfo });
+      return;
+    }
+
+    const press = normalizedSlug
+      ? findManifestPress(manifest, normalizedSlug)
+      : manifest.presses[0];
+    if (!press) {
+      setState({
+        status: "error",
+        message: `Unknown document slug "/${normalizedSlug}". Known: ${manifest.presses.map((p) => `/${p.slug}`).join(", ")}.`,
+      });
+      return;
+    }
+    const document = await loadReaderDocument(press.documentUrl);
+    setState({ status: "ready", document, deploymentInfo, manifest, activeSlug: press.slug });
+  }, []);
+
+  const refreshDocument = useCallback(async () => {
+    if (state.status !== "ready") return;
+    const press = state.manifest
+      ? findManifestPress(state.manifest, state.activeSlug)
+      : null;
+    const url = press?.documentUrl ?? "/openpress/document.json";
+    const document = await loadReaderDocument(url);
+    setState((latest) => {
+      if (latest.status !== "ready") return latest;
+      return { ...latest, document };
+    });
+  }, [state]);
+
+  // Gallery click → pushState + load. Bypasses resolveFromSlug's
+  // "empty slug + multi-Press → gallery" branch: an explicit click on
+  // the unslugged root Press must enter it, not bounce back to gallery.
+  const enterPress = useCallback(async (press: WorkspaceManifestPress) => {
+    if (state.status !== "gallery") return;
+    pushSlug(press.slug);
+    setState({ status: "loading" });
+    try {
+      const document = await loadReaderDocument(press.documentUrl);
+      setState({
+        status: "ready",
+        document,
+        deploymentInfo: state.deploymentInfo,
+        manifest: state.manifest,
+        activeSlug: press.slug,
+      });
+    } catch (error) {
+      setState({
+        status: "error",
+        message: error instanceof Error ? error.message : "Unable to load OpenPress document.",
+      });
+    }
+  }, [state]);
+
+  // Bootstrap: read URL → load manifest + deploy info → resolve.
+  useEffect(() => {
+    let cancelled = false;
+
+    async function bootstrap() {
+      try {
+        const [manifest, deploymentInfo] = await Promise.all([
+          loadWorkspaceManifest(),
+          loadDeploymentInfo(),
+        ]);
+        if (cancelled) return;
+        await resolveFromSlug(manifest, currentSlugFromLocation(), deploymentInfo);
+      } catch (error) {
+        if (!cancelled) {
+          setState({
+            status: "error",
+            message: error instanceof Error ? error.message : "Unable to load OpenPress document.",
+          });
+        }
+      }
+    }
+
+    void bootstrap();
+    return () => {
+      cancelled = true;
+    };
+  }, [resolveFromSlug]);
+
+  // Back / forward button — re-resolve from the new URL.
+  useEffect(() => {
+    function onPopState() {
+      if (state.status === "loading") return;
+      const manifest = state.status === "gallery"
+        ? state.manifest
+        : state.status === "ready"
+        ? state.manifest
+        : null;
+      const deploymentInfo = state.status === "gallery" || state.status === "ready"
+        ? state.deploymentInfo
+        : offlineDeploymentInfo;
+      void resolveFromSlug(manifest, currentSlugFromLocation(), deploymentInfo);
+    }
+    window.addEventListener("popstate", onPopState);
+    return () => window.removeEventListener("popstate", onPopState);
+  }, [state, resolveFromSlug]);
+
+  if (state.status === "loading") return <LoadingScreen />;
+
+  if (state.status === "error") {
+    return <div className="openpress-load-state openpress-load-state--error">{state.message}</div>;
+  }
+
+  if (state.status === "gallery") {
+    return <WorkspaceGalleryPage manifest={state.manifest} onSelectPress={enterPress} />;
+  }
+
+  // Only multi-Press workspaces have a gallery to go back to. Single-Press
+  // workspaces don't render the button (no destination exists).
+  const backToWorkspace = state.manifest && manifestHasMultiplePresses(state.manifest)
+    ? () => {
+        if (state.status !== "ready" || !state.manifest) return;
+        pushSlug("");
+        setState({
+          status: "gallery",
+          manifest: state.manifest,
+          deploymentInfo: state.deploymentInfo,
+        });
+      }
+    : undefined;
+
+  return (
+    <OpenPressRuntime
+      document={state.document}
+      deploymentInfo={state.deploymentInfo}
+      onDocumentRefresh={refreshDocument}
+      onBackToWorkspace={backToWorkspace}
+    />
+  );
+}
+
+function currentSlugFromLocation(): string {
+  if (typeof window === "undefined") return "";
+  return normalizeSlug(window.location.pathname);
+}
+
+function normalizeSlug(raw: string): string {
+  return raw.replace(/^\/+|\/+$/g, "");
+}
+
+function pushSlug(slug: string) {
+  if (typeof window === "undefined") return;
+  // Preserve the current query string (e.g. ?dev=1 keeps the workbench
+  // chrome alive across gallery navigation). Drop the hash — it's a
+  // page anchor that means nothing in a different document.
+  const pathname = slug ? `/${normalizeSlug(slug)}` : "/";
+  const target = `${pathname}${window.location.search}`;
+  if (window.location.pathname === pathname) return;
+  window.history.pushState({}, "", target);
+}
+
+async function loadWorkspaceManifest(): Promise<WorkspaceManifest | null> {
+  // Optional — older deployments don't ship workspace.json. The reader
+  // falls back to /openpress/document.json directly when missing, which
+  // matches pre-v1.0 behavior.
+  try {
+    const response = await fetch("/openpress/workspace.json", { cache: "no-store" });
+    if (!response.ok) return null;
+    return (await response.json()) as WorkspaceManifest;
+  } catch {
+    return null;
+  }
+}
+
+async function loadReaderDocument(url: string): Promise<ReaderDocument> {
+  const response = await fetch(url, { cache: "no-store" });
+  if (!response.ok) {
+    throw new Error(`Unable to load ${url} (${response.status})`);
+  }
+  return (await response.json()) as ReaderDocument;
+}
+
+async function loadDeploymentInfo(): Promise<DeploymentInfo> {
+  if (typeof window !== "undefined" && isLocalWorkspaceHost(window.location.hostname)) {
+    const localInfo = await loadDeploymentInfoFrom("/__openpress/status");
+    if (localInfo) return localInfo;
+  }
+
+  return (await loadDeploymentInfoFrom("/openpress/deploy.json")) ?? offlineDeploymentInfo;
+}
+
+async function loadDeploymentInfoFrom(path: string): Promise<DeploymentInfo | null> {
+  try {
+    const response = await fetch(path, { cache: "no-store" });
+    if (!response.ok) {
+      return null;
+    }
+    const config = (await response.json()) as DeployConfig;
+    return deploymentConfigToInfo(config);
+  } catch {
+    return null;
+  }
+}
+
+function deploymentConfigToInfo(config: DeployConfig): DeploymentInfo {
+  const configured = config.deploy_configured !== false;
+  return {
+    online: configured && Boolean(config.deployed_at || config.public_url),
+    deployedAt: config.deployed_at,
+    pdf: typeof config.pdf === "string" ? config.pdf : undefined,
+    publicUrl: typeof config.public_url === "string" ? config.public_url : undefined,
+    dirty: config.dirty === true,
+    configured,
+    adapter: typeof config.deploy_adapter === "string" ? config.deploy_adapter : undefined,
+    source: typeof config.deploy_source === "string" ? config.deploy_source : undefined,
+    projectName: typeof config.deploy_project_name === "string" ? config.deploy_project_name : undefined,
+    setupMessage: typeof config.deploy_setup_message === "string" ? config.deploy_setup_message : undefined,
+  };
+}

package/template/core/src/openpress/{renderer.tsx → app/OpenPressRuntime.tsx}

@@ -1,23 +1,30 @@
 import { useMemo, type CSSProperties } from "react";
-import { PrintDocument, PublicViewer } from "./publicPage";
-import { isPrintModeLocation, isWorkspaceModeLocation } from "./runtimeMode";
-import { HtmlWorkbench } from "./workbench";
+import { PrintDocument, PublicViewer } from "../reader";
+import { isPrintModeLocation, isWorkspaceModeLocation } from "../shared";
+import { HtmlWorkbench } from "../workbench";
 import type {
   DeploymentInfo,
   ReaderDocument,
   HtmlPageBlock,
   Theme,
-} from "./types";
+} from "../document-model";
 
-interface RendererProps {
+interface OpenPressRuntimeProps {
   document: ReaderDocument;
   deploymentInfo?: DeploymentInfo;
+  onDocumentRefresh?: () => void | Promise<void>;
+  // Optional — supplied by OpenPressApp when this Press was entered from
+  // a multi-Press gallery. Renders a "工作台" home button in the toolbar
+  // that returns to the gallery without a full page reload.
+  onBackToWorkspace?: () => void;
 }
 
-export function Renderer({
+export function OpenPressRuntime({
   document,
   deploymentInfo = { online: false },
-}: RendererProps) {
+  onDocumentRefresh,
+  onBackToWorkspace,
+}: OpenPressRuntimeProps) {
   const style = themeToCssVariables(document.theme);
   const htmlPages = document.blocks.filter((block): block is HtmlPageBlock => block.kind === "htmlPage");
   const workspaceMode = useMemo(() => {
@@ -45,6 +52,8 @@ export function Renderer({
         style={style}
         devMode={workspaceMode}
         deploymentInfo={deploymentInfo}
+        onDocumentRefresh={onDocumentRefresh}
+        onBackToWorkspace={onBackToWorkspace}
       />
     );
   }
@@ -59,11 +68,11 @@ function EmptyState({ style, workspaceMode }: { style: CSSProperties; workspaceM
         <p className="openpress-empty-state__eyebrow">OpenPress</p>
         <h1 className="openpress-empty-state__title">This document has no content yet.</h1>
         <p className="openpress-empty-state__body">
-          Add React MDX chapter files under <code>document/chapters/**/content/</code>, then re-export.
+          Add React MDX chapter files under <code>press/chapters/**/content/</code>, then re-build.
         </p>
         {workspaceMode ? (
           <ol className="openpress-empty-state__steps">
-            <li><code>npm run openpress:export</code> &nbsp;— refreshes <code>public/openpress/document.json</code></li>
+            <li><code>npm run build</code> &nbsp;— validates and refreshes <code>public/openpress/document.json</code></li>
             <li>Reload this page</li>
           </ol>
         ) : (
@@ -85,6 +94,8 @@ function themeToCssVariables(theme?: Theme) {
 
   if (theme?.pageWidth) style["--openpress-page-width"] = theme.pageWidth;
   if (theme?.pageHeight) style["--openpress-page-height"] = theme.pageHeight;
+  if (theme?.pageAspectRatio) style["--openpress-page-aspect-ratio"] = theme.pageAspectRatio;
+  if (theme?.pageHeightRatio) style["--openpress-page-height-ratio"] = theme.pageHeightRatio;
   if (theme?.pagePadding) style["--openpress-page-padding"] = theme.pagePadding;
 
   return style;