@open-press/cli 0.3.0 → 0.5.0

package/dist/cli.js

@@ -6,7 +6,7 @@ import process2 from "process";
 // src/init.ts
 import { spawn } from "child_process";
 import { existsSync } from "fs";
-import { cp, mkdir as mkdir2, readdir, rm as rm2 } from "fs/promises";
+import { cp, mkdir as mkdir2, rm as rm2 } from "fs/promises";
 import path2 from "path";
 import process from "process";
 import { fileURLToPath } from "url";
@@ -23,8 +23,8 @@ async function pathIsEmpty(target) {
   try {
     const s = await stat(target);
     if (!s.isDirectory()) return false;
-    const { readdir: readdir2 } = await import("fs/promises");
-    const entries = await readdir2(target);
+    const { readdir } = await import("fs/promises");
+    const entries = await readdir(target);
     return entries.length === 0;
   } catch {
     return true;
@@ -81,10 +81,11 @@ async function patchPackageJsonName(packagePath, newName) {
 
 // src/init.ts
 var KNOWN_PACKS = ["editorial-monograph", "claude-document"];
+var SKILLS_SOURCE = "quan0715/open-press";
 var __dirname = path2.dirname(fileURLToPath(import.meta.url));
 var TEMPLATE_ROOT = path2.resolve(__dirname, "..", "template");
 var TEMPLATE_CORE = path2.join(TEMPLATE_ROOT, "core");
-var TEMPLATE_SKILLS = path2.join(TEMPLATE_ROOT, "skills");
+var TEMPLATE_PACKS = path2.join(TEMPLATE_ROOT, "packs");
 async function init(options) {
   validatePack(options.pack);
   ensureTemplateBundled();
@@ -98,16 +99,14 @@ async function init(options) {
     log(`Applying style pack: ${options.pack}`);
     await rm2(docDest, { recursive: true, force: true });
     await mkdir2(docDest, { recursive: true });
-    const packStarter = path2.join(TEMPLATE_SKILLS, options.pack, "starter", "document");
+    const packStarter = path2.join(TEMPLATE_PACKS, options.pack, "document");
     if (!existsSync(packStarter)) {
-      throw new Error(`Style pack starter not found: ${packStarter}`);
+      throw new Error(`Style pack starter not found in bundle: ${packStarter}`);
     }
     await cp(packStarter, docDest, { recursive: true });
   } else {
     await mkdir2(docDest, { recursive: true });
   }
-  log("Installing SKILL files\u2026");
-  await installSkills(target);
   const pkgPath = path2.join(target, "package.json");
   if (existsSync(pkgPath)) {
     await patchPackageJsonName(pkgPath, path2.basename(target));
@@ -122,6 +121,13 @@ async function init(options) {
       author: options.author
     });
   }
+  log(`Installing agent skills via \`npx skills add ${SKILLS_SOURCE}\`\u2026`);
+  try {
+    await runInTarget(target, "npx", ["-y", "skills@latest", "add", SKILLS_SOURCE]);
+  } catch (err) {
+    log(`(skills install failed; you can retry manually with \`npx skills add ${SKILLS_SOURCE}\`)`);
+    log(`  reason: ${err instanceof Error ? err.message : String(err)}`);
+  }
   if (options.install) {
     log("Installing dependencies (npm install)\u2026");
     await runInTarget(target, "npm", ["install"]);
@@ -142,33 +148,8 @@ async function init(options) {
   }
   printNextSteps(target, options);
 }
-async function installSkills(target) {
-  const skillDirs = await readdir(TEMPLATE_SKILLS, { withFileTypes: true });
-  const claudeRoot = path2.join(target, ".claude", "skills");
-  const agentsRoot = path2.join(target, ".agents", "skills");
-  await mkdir2(claudeRoot, { recursive: true });
-  await mkdir2(agentsRoot, { recursive: true });
-  for (const dir of skillDirs) {
-    if (!dir.isDirectory()) continue;
-    const source = path2.join(TEMPLATE_SKILLS, dir.name);
-    const claudeTarget = path2.join(claudeRoot, dir.name);
-    const agentsTarget = path2.join(agentsRoot, dir.name);
-    await copySkillFiles(source, claudeTarget);
-    await copySkillFiles(source, agentsTarget);
-  }
-}
-async function copySkillFiles(source, dest) {
-  await mkdir2(dest, { recursive: true });
-  const entries = await readdir(source, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.name === "starter" || entry.name === "agents") continue;
-    const from = path2.join(source, entry.name);
-    const to = path2.join(dest, entry.name);
-    await cp(from, to, { recursive: true });
-  }
-}
 function ensureTemplateBundled() {
-  if (!existsSync(TEMPLATE_CORE) || !existsSync(TEMPLATE_SKILLS)) {
+  if (!existsSync(TEMPLATE_CORE) || !existsSync(TEMPLATE_PACKS)) {
     throw new Error(
       `Template not bundled at ${TEMPLATE_ROOT}. If running from source, run \`pnpm sync:template\` in packages/cli first.`
     );
@@ -216,7 +197,7 @@ function printNextSteps(target, options) {
   const rel = path2.relative(process.cwd(), target) || ".";
   const lines = [
     "",
-    "\u2713 Done! Your open-press workspace is ready.",
+    "\u2713 Done. Your open-press workspace is ready.",
     "",
     "Next steps:",
     `  cd ${rel}`
@@ -229,9 +210,11 @@ function printNextSteps(target, options) {
     "  # start the workbench:",
     "  npm run dev",
     "",
-    "Then open the local URL printed by vite (typically http://127.0.0.1:5173/?dev=1).",
+    "Then open the local URL printed by Vite (typically http://127.0.0.1:5173/?dev=1).",
+    "",
+    "Agent skills installed under .agents/skills/ (universal \u2014 read by Claude Code,",
+    `Cursor, Codex, Gemini CLI, etc.). Update later with: npx skills upgrade`,
     "",
-    "AI agent skills are installed under .claude/skills/ and .agents/skills/.",
     "Edit content under document/chapters/, or ask your AI agent to help.",
     ""
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-press/cli",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "type": "module",
   "description": "Scaffolder for open-press — AI-first fixed-layout document workspaces.",
   "license": "MIT",

package/template/core/CHANGELOG.md

@@ -1,5 +1,48 @@
 # @open-press/core
 
+## 0.5.0
+
+### Minor Changes
+
+- 0169cba: Agent-driven upgrade flow.
+
+  **New commands:**
+
+  - `npx open-press doctor` — diagnose workspace against latest framework state. Reports `@open-press/core` version vs npm latest, installed skill count, and any pending `docs/migrations/<version>.md` notes between current and latest. `--json` for machine-readable output, `--no-cache` to bypass the 24h cache. Always exits 0 (informational only).
+
+  - `npx open-press upgrade` — orchestrate the upgrade. Runs `npm update @open-press/core` (when the workspace declares the dep) and `npx skills upgrade`, then surfaces the list of migration notes for the agent to read. **Does not auto-edit `document/` content** — the agent reads the surfaced `docs/migrations/<version>.md` notes and proposes edits to the user with confirmation. Use `--dry-run` to preview, `--no-deps` / `--no-skills` to target one layer.
+
+  **Dev startup notice:**
+
+  `open-press dev` now runs `doctor` before starting Vite. When the workspace is behind, a single line prints: `○ open-press: @open-press/core 0.4.0 → 0.5.0 · 1 migration note(s) — run npx open-press doctor for details.` Cached for 24h, network failure is silent, never blocks dev.
+
+  **Migration docs:**
+
+  - New `docs/migrations/_template.md` — each release with breaking changes ships a `docs/migrations/<version>.md` file with sections the agent reads.
+  - New `docs/migrations/0.4.0.md` — backfilled. Documents the SKILL fold (no document or CLI changes).
+
+  **SKILL update:**
+
+  `openpress` skill's "Updating An Existing Workspace" section rewritten around the new commands: detect (`doctor`), apply (`upgrade`), interpret migration notes, propose document edits with user confirmation. Concrete agent workflow + breaking-change reference table.
+
+### Patch Changes
+
+- 931d4ac: Support framework root dogfood workspaces and correct CLI script paths outside the core package root.
+
+## 0.4.0
+
+### Minor Changes
+
+- 3cb4939: Consolidate internal skills (13 → 11).
+
+  - `openpress-update` folded into `openpress` as an "Updating An Existing Workspace" section. The release-upgrade flow, pre-flight checks, breaking-change reference, and do-not list are now part of the system-operation skill where they naturally belong.
+  - `openpress-document-hierarchy` folded into `openpress-writing` as a "Hierarchy" section. Hierarchy decisions (H2/H3/H4 model, TOC depth, appendix placement, H4 granularity) and prose decisions happen in the same workflow; one skill, one routing decision.
+  - `references/data-structures-outline.md` moved from the hierarchy skill into `openpress-writing/references/`.
+
+  Lower maintenance surface: 2 fewer SKILL.md files to keep in sync, ~5 fewer cross-references to police. No content lost — same rules, fewer files.
+
+  User impact: agents already in workspaces with `openpress-update` or `openpress-document-hierarchy` SKILL files installed should run `npx skills upgrade` to refresh the catalog.
+
 ## 0.3.0
 
 ### Minor Changes

package/template/core/engine/cli.mjs

@@ -2,6 +2,7 @@
 
 import * as deployCmd from "./commands/deploy.mjs";
 import * as devCmd from "./commands/dev.mjs";
+import * as doctorCmd from "./commands/doctor.mjs";
 import * as exportCmd from "./commands/export.mjs";
 import * as initCmd from "./commands/init.mjs";
 import * as inspectCmd from "./commands/inspect.mjs";
@@ -12,6 +13,7 @@ import * as replaceCmd from "./commands/replace.mjs";
 import * as renderCmd from "./commands/render.mjs";
 import * as searchCmd from "./commands/search.mjs";
 import * as typecheckCmd from "./commands/typecheck.mjs";
+import * as upgradeCmd from "./commands/upgrade.mjs";
 import * as validateCmd from "./commands/validate.mjs";
 import { parseOptions } from "./commands/_shared.mjs";
 import { loadConfig } from "./config.mjs";
@@ -32,6 +34,8 @@ const COMMANDS = {
   typecheck: typecheckCmd,
   pdf: pdfCmd,
   deploy: deployCmd,
+  doctor: doctorCmd,
+  upgrade: upgradeCmd,
 };
 
 const args = process.argv.slice(2);
@@ -87,6 +91,8 @@ Commands:
   typecheck
   pdf [--output <outputDir>/<pdf.filename>] [--no-build] [--dry-run]
   deploy --confirm [--dry-run]
+  doctor [--json] [--no-cache]                          # version + skill staleness check
+  upgrade [--dry-run] [--no-deps] [--no-skills] [--json] # apply updates; agent-driven
 
 Style packs available for \`init --skill\`: ${skillList}
 `);

package/template/core/engine/commands/_shared.mjs

@@ -7,8 +7,9 @@ import { loadConfig, publicPdfHref } from "../config.mjs";
 import { exportDocument } from "../document-export.mjs";
 import { optimizePdfMediaForStaticRoot } from "../pdf-media.mjs";
 
-const ENGINE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const STATIC_SERVER = path.join(ENGINE_DIR, "static-server.mjs");
+export const ENGINE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+export const CLI_ENTRY = path.join(ENGINE_DIR, "cli.mjs");
+export const STATIC_SERVER = path.join(ENGINE_DIR, "static-server.mjs");
 
 export function parseOptions(argv) {
   const options = {};
@@ -62,6 +63,12 @@ export function runCommand(commandName, commandArgs, cwd) {
   return result.status ?? 1;
 }
 
+export function formatNodeScriptCommand(root, scriptPath) {
+  const relative = path.relative(root, scriptPath).replaceAll("\\", "/");
+  const displayPath = relative && !relative.startsWith("../") ? relative : scriptPath;
+  return `node ${displayPath}`;
+}
+
 export async function buildReactStatic({ root, noBuild = false, recurse, silent = false }) {
   if (noBuild) return 0;
   if (!silent) {

package/template/core/engine/commands/deploy.mjs

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { deploySync } from "../deploy-sync.mjs";
-import { buildReactPdf, runCommand, writePdfStageDeployConfig } from "./_shared.mjs";
+import { CLI_ENTRY, buildReactPdf, formatNodeScriptCommand, runCommand, writePdfStageDeployConfig } from "./_shared.mjs";
 
 export async function run({ root, config, options, recurse }) {
   if (config.deploy.requiresConfirmation === true && !options.confirm) {
@@ -12,9 +12,9 @@ export async function run({ root, config, options, recurse }) {
   const commitDirty = config.deploy.commitDirty;
   if (options.dryRun) {
     console.log("OpenPress deploy dry run");
-    console.log("Command: node engine/cli.mjs render . --renderer react");
+    console.log(`Command: ${formatNodeScriptCommand(root, CLI_ENTRY)} render . --renderer react`);
     console.log(`Step:    deploy-sync (copy ${config.outputDir} → ${source})`);
-    console.log(`Command: node engine/cli.mjs pdf . --output ${source}/${config.pdf.filename}`);
+    console.log(`Command: ${formatNodeScriptCommand(root, CLI_ENTRY)} pdf . --output ${source}/${config.pdf.filename}`);
     console.log(`Step:    write ${source}/openpress/deploy.json with deployment metadata`);
     console.log(`Command: npx wrangler pages deploy ${source}${projectName ? ` --project-name=${projectName}` : ""}${commitDirty ? " --commit-dirty=true" : ""}`);
     return 0;

package/template/core/engine/commands/dev.mjs

@@ -1,5 +1,6 @@
 import { exportDocument } from "../document-export.mjs";
-import { runCommand } from "./_shared.mjs";
+import { diagnose } from "./doctor.mjs";
+import { CLI_ENTRY, formatNodeScriptCommand, runCommand } from "./_shared.mjs";
 
 export async function run({ root, options }) {
   const renderer = options.renderer ?? "react";
@@ -13,7 +14,7 @@ export async function run({ root, options }) {
   if (options.dryRun) {
     console.log(`OpenPress dev URL: ${url}`);
     if (!options.noBuild) {
-      console.log("Command: node engine/cli.mjs export .");
+      console.log(`Command: ${formatNodeScriptCommand(root, CLI_ENTRY)} export .`);
     }
     console.log(`Command: npx vite --config vite.config.ts --host ${host} --port ${port}`);
     return 0;
@@ -21,6 +22,28 @@ export async function run({ root, options }) {
   if (!options.noBuild) {
     await exportDocument(root);
   }
+
+  // One-line update notice (24h cached, network failure is silent).
+  await printDoctorNoticeIfStale(root);
+
   console.log(`OpenPress dev: ${url}`);
   return runCommand("npx", ["vite", "--config", "vite.config.ts", "--host", host, "--port", port], root);
 }
+
+async function printDoctorNoticeIfStale(root) {
+  try {
+    const report = await diagnose(root);
+    if (!report.stale) return;
+    const parts = [];
+    if (report.coreUpdateAvailable) {
+      parts.push(`@open-press/core ${report.coreVersion} → ${report.coreLatest}`);
+    }
+    if (report.pendingMigrations.length > 0) {
+      parts.push(`${report.pendingMigrations.length} migration note(s)`);
+    }
+    if (parts.length === 0) return;
+    console.log(`○ open-press: ${parts.join(" · ")} — run \`npx open-press doctor\` for details.`);
+  } catch {
+    // Doctor is informational only; never block dev.
+  }
+}

package/template/core/engine/commands/doctor.mjs

@@ -0,0 +1,229 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24h
+const CORE_PACKAGE = "@open-press/core";
+
+export async function run({ root, options }) {
+  const json = Boolean(options?.json);
+  const noCache = Boolean(options?.noCache);
+
+  const report = await diagnose(root, { noCache });
+
+  if (json) {
+    process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+  } else {
+    printHumanReport(report);
+  }
+
+  // Exit 0 even when stale — doctor is informational, not a gate.
+  // Agents / CI can check report.stale or report.coreUpdateAvailable.
+  return 0;
+}
+
+/**
+ * Diagnose workspace against latest framework state.
+ * Result shape:
+ *   {
+ *     coreVersion: "0.4.0",                    // installed
+ *     coreLatest: "0.5.0" | null,              // null on network failure
+ *     coreUpdateAvailable: boolean,
+ *     skillsInstalled: ["openpress", ...],
+ *     skillsLockSource: "quan0715/open-press" | null,
+ *     pendingMigrations: ["0.5.0"],            // versions with docs/migrations notes
+ *     stale: boolean,                          // either core or skills behind
+ *     cachedAt: ISO timestamp
+ *   }
+ */
+export async function diagnose(root, { noCache = false } = {}) {
+  const cachePath = path.join(root, ".openpress", "cache", "doctor.json");
+
+  if (!noCache) {
+    const cached = await readCached(cachePath);
+    if (cached) return cached;
+  }
+
+  const coreVersion = await readCoreVersion(root);
+  const coreLatest = await fetchCoreLatest();
+  const skillsInstalled = await listInstalledSkills(root);
+  const skillsLockSource = await readSkillsLockSource(root);
+  const pendingMigrations = await listPendingMigrations(root, coreVersion, coreLatest);
+
+  const coreUpdateAvailable = Boolean(
+    coreVersion && coreLatest && coreVersion !== coreLatest && semverLt(coreVersion, coreLatest),
+  );
+
+  const report = {
+    coreVersion,
+    coreLatest,
+    coreUpdateAvailable,
+    skillsInstalled,
+    skillsLockSource,
+    pendingMigrations,
+    stale: coreUpdateAvailable || pendingMigrations.length > 0,
+    cachedAt: new Date().toISOString(),
+  };
+
+  await writeCached(cachePath, report).catch(() => {});
+  return report;
+}
+
+async function readCached(cachePath) {
+  try {
+    const stats = await stat(cachePath);
+    if (Date.now() - stats.mtimeMs > CACHE_TTL_MS) return null;
+    return JSON.parse(await readFile(cachePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+async function writeCached(cachePath, report) {
+  await mkdir(path.dirname(cachePath), { recursive: true });
+  await writeFile(cachePath, JSON.stringify(report, null, 2) + "\n", "utf8");
+}
+
+async function readCoreVersion(root) {
+  // Try workspace package.json deps first; fall back to installed package.
+  try {
+    const pkg = JSON.parse(await readFile(path.join(root, "package.json"), "utf8"));
+    const range = pkg.dependencies?.[CORE_PACKAGE] ?? pkg.devDependencies?.[CORE_PACKAGE];
+    if (range) {
+      // Try the installed version (more accurate than the range).
+      try {
+        const installed = JSON.parse(
+          await readFile(path.join(root, "node_modules", CORE_PACKAGE, "package.json"), "utf8"),
+        );
+        return installed.version;
+      } catch {
+        return range.replace(/^[\^~>=<\s]+/, "");
+      }
+    }
+  } catch {}
+
+  // Self-bundled framework (cli scaffolded workspace): pkg.version is the framework version.
+  try {
+    const pkg = JSON.parse(await readFile(path.join(root, "package.json"), "utf8"));
+    if (pkg.name === CORE_PACKAGE) return pkg.version;
+  } catch {}
+
+  return null;
+}
+
+async function fetchCoreLatest() {
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${CORE_PACKAGE}/latest`, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+
+async function listInstalledSkills(root) {
+  const skillsDir = path.join(root, ".agents", "skills");
+  try {
+    const { readdir } = await import("node:fs/promises");
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+}
+
+async function readSkillsLockSource(root) {
+  try {
+    const lock = JSON.parse(await readFile(path.join(root, "skills-lock.json"), "utf8"));
+    const sources = lock?.sources;
+    if (Array.isArray(sources) && sources.length > 0) return sources[0]?.source ?? null;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+async function listPendingMigrations(root, currentVersion, latestVersion) {
+  if (!currentVersion || !latestVersion || !semverLt(currentVersion, latestVersion)) return [];
+  // Look for docs/migrations/<version>.md files for versions in (current, latest].
+  const migrationsDir = path.join(root, "docs", "migrations");
+  try {
+    const { readdir } = await import("node:fs/promises");
+    const files = await readdir(migrationsDir);
+    return files
+      .filter((f) => /^\d+\.\d+\.\d+\.md$/.test(f))
+      .map((f) => f.replace(/\.md$/, ""))
+      .filter((v) => semverGt(v, currentVersion) && !semverGt(v, latestVersion))
+      .sort(semverCompare);
+  } catch {
+    return [];
+  }
+}
+
+function semverParse(v) {
+  const m = /^(\d+)\.(\d+)\.(\d+)/.exec(v);
+  if (!m) return [0, 0, 0];
+  return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+function semverCompare(a, b) {
+  const A = semverParse(a);
+  const B = semverParse(b);
+  for (let i = 0; i < 3; i++) if (A[i] !== B[i]) return A[i] - B[i];
+  return 0;
+}
+function semverLt(a, b) { return semverCompare(a, b) < 0; }
+function semverGt(a, b) { return semverCompare(a, b) > 0; }
+
+function printHumanReport(report) {
+  const lines = [];
+  lines.push("○ open-press doctor");
+  lines.push("");
+  lines.push("framework");
+  if (report.coreVersion) {
+    if (report.coreLatest === null) {
+      lines.push(`  ? @open-press/core: ${report.coreVersion} installed (couldn't check latest — offline?)`);
+    } else if (report.coreUpdateAvailable) {
+      lines.push(`  ⚠ @open-press/core: ${report.coreVersion} installed → ${report.coreLatest} available`);
+    } else {
+      lines.push(`  ✓ @open-press/core: ${report.coreVersion} (latest)`);
+    }
+  } else {
+    lines.push("  ? @open-press/core: not detected in this workspace");
+  }
+  lines.push("");
+  lines.push("skills");
+  if (report.skillsInstalled.length === 0) {
+    lines.push("  ? no skills installed under .agents/skills/");
+    lines.push("    run: npx skills add quan0715/open-press");
+  } else {
+    lines.push(`  ✓ ${report.skillsInstalled.length} skills installed`);
+    if (report.skillsLockSource) {
+      lines.push(`    source: ${report.skillsLockSource}`);
+      lines.push("    refresh: npx skills upgrade");
+    }
+  }
+  lines.push("");
+  lines.push("migrations");
+  if (report.pendingMigrations.length === 0) {
+    if (report.coreUpdateAvailable) {
+      lines.push(`  ✓ no breaking migrations documented for the ${report.coreLatest} window`);
+    } else {
+      lines.push("  ✓ up to date");
+    }
+  } else {
+    lines.push(`  ⚠ ${report.pendingMigrations.length} migration note(s) since your version:`);
+    for (const v of report.pendingMigrations) lines.push(`    - docs/migrations/${v}.md`);
+  }
+  lines.push("");
+  if (report.stale) {
+    lines.push("next");
+    lines.push("  npx open-press upgrade        # apply all updates (agent-driven)");
+    lines.push("  npx open-press doctor --json  # machine-readable output");
+    lines.push("");
+  }
+  process.stdout.write(lines.join("\n"));
+}

package/template/core/engine/commands/pdf.mjs

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { buildReactPdf } from "./_shared.mjs";
+import { CLI_ENTRY, STATIC_SERVER, buildReactPdf, formatNodeScriptCommand } from "./_shared.mjs";
 
 export async function run({ root, config, options, recurse }) {
   const outputPath = options.output ? path.resolve(root, options.output) : undefined;
@@ -7,8 +7,8 @@ export async function run({ root, config, options, recurse }) {
     const relOutput = path.relative(root, outputPath ?? config.paths.pdf);
     const host = options.host ?? "127.0.0.1";
     const port = options.port ?? "5185";
-    console.log("Command: node engine/cli.mjs render . --renderer react");
-    console.log(`Command: node engine/static-server.mjs ${config.outputDir} --host ${host} --port ${port} --workspace .`);
+    console.log(`Command: ${formatNodeScriptCommand(root, CLI_ENTRY)} render . --renderer react`);
+    console.log(`Command: ${formatNodeScriptCommand(root, STATIC_SERVER)} ${config.outputDir} --host ${host} --port ${port} --workspace .`);
     console.log(`Command: Chrome --print-to-pdf=${relOutput} http://${host}:${port}/?print=1`);
     return 0;
   }

package/template/core/engine/commands/preview.mjs

@@ -1,4 +1,4 @@
-import { runCommand } from "./_shared.mjs";
+import { CLI_ENTRY, STATIC_SERVER, formatNodeScriptCommand, runCommand } from "./_shared.mjs";
 
 export async function run({ root, config, options, recurse }) {
   const renderer = options.renderer ?? "react";
@@ -12,9 +12,9 @@ export async function run({ root, config, options, recurse }) {
   if (options.dryRun) {
     console.log(`OpenPress preview URL: ${url}`);
     if (!options.noBuild) {
-      console.log("Command: node engine/cli.mjs render . --renderer react");
+      console.log(`Command: ${formatNodeScriptCommand(root, CLI_ENTRY)} render . --renderer react`);
     }
-    console.log(`Command: node engine/static-server.mjs ${config.outputDir} --host ${host} --port ${port} --workspace .`);
+    console.log(`Command: ${formatNodeScriptCommand(root, STATIC_SERVER)} ${config.outputDir} --host ${host} --port ${port} --workspace .`);
     return 0;
   }
   if (!options.noBuild) {
@@ -22,5 +22,5 @@ export async function run({ root, config, options, recurse }) {
     if (renderCode !== 0) return renderCode;
   }
   console.log(`OpenPress preview: ${url}`);
-  return runCommand("node", ["engine/static-server.mjs", config.outputDir, "--host", host, "--port", port, "--workspace", "."], root);
+  return runCommand("node", [STATIC_SERVER, config.outputDir, "--host", host, "--port", port, "--workspace", "."], root);
 }