@myna-sh/cli 0.11.0 → 0.12.0

package/README.md

@@ -64,6 +64,30 @@ myna changes diff chs_...
 
 Run `myna --help` or `myna <command> --help` for the complete command reference. Global flags include `--json`, `--organization`, `--project`, `--token`, and `--api-url`.
 
+## Pin content to a release
+
+`myna.lock` records the release a repository builds against, so the same commit
+builds the same site. `myna pull` moves it.
+
+```sh
+myna pull                 # pin to the newest release
+myna pull --release 42    # pin to a specific one
+myna pull --check         # non-zero exit when the pin is behind (for CI)
+myna pull --open-pr       # bump on a branch and open a pull request
+```
+
+`--open-pr` writes a pull request whose body is the field-level diff of every
+release being taken on, so CI runs the real build against the new content before
+anyone merges it. It needs `git` and the GitHub CLI. Read the pin with
+`readLock()` from `@myna-sh/sdk/lock` and pass it to `createMyna({ release })`.
+
+Add `--run` when the repository generates something from content, and the
+regenerated artifact is committed with the pin that produced it:
+
+```sh
+myna pull --open-pr --run 'pnpm build:content'
+```
+
 ## Environment
 
 ```text

package/dist/main.js

@@ -1533,7 +1533,7 @@ function registerWorkspace(program) {
 
 // src/commands/schema.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 
 // src/schema-loader.ts
 import { existsSync as existsSync3, readdirSync, statSync } from "fs";
@@ -1769,6 +1769,8 @@ function varName(name) {
 // src/git.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import { createHash as createHash2 } from "crypto";
+import { rmSync as rmSync2 } from "fs";
+import { join as join4 } from "path";
 function run(command, args, cwd) {
   try {
     return execFileSync2(command, args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
@@ -1799,6 +1801,10 @@ function branchForContent(contents) {
   const digest = createHash2("sha256").update(contents.join("\0")).digest("hex").slice(0, 8);
   return `myna/schema-${digest}`;
 }
+function branchForRelease(project, release) {
+  const slug = project.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "project";
+  return `myna/content-${slug}-r${release}`;
+}
 function openPullRequest(input) {
   if (!available("git")) throw new CliError("git is required to open a pull request.");
   if (!available("gh")) {
@@ -1848,6 +1854,22 @@ function dirtyFiles(cwd, paths) {
   if (paths.length === 0) return [];
   return run("git", ["status", "--porcelain", "--", ...paths], cwd).split("\n").filter(Boolean).map((line) => line.slice(3).trim());
 }
+function repositoryRoot(cwd) {
+  return git(["rev-parse", "--show-toplevel"], cwd);
+}
+function worktreeChanges(cwd) {
+  const root = repositoryRoot(cwd);
+  return run("git", ["status", "--porcelain"], cwd).split("\n").filter(Boolean).map((line) => ({
+    file: join4(root, line.slice(3).trim()),
+    untracked: line.startsWith("??")
+  }));
+}
+function discardChanges(cwd, changes) {
+  for (const change of changes) {
+    if (change.untracked) rmSync2(change.file, { force: true, recursive: true });
+    else gitQuiet(["checkout", "--", change.file], cwd);
+  }
+}
 
 // src/commands/schema.ts
 async function deployedSchemas(ctx, project) {
@@ -1899,7 +1921,7 @@ function registerSchema(program) {
       const project = ctx.requireProject();
       const dir = schemaDirFor(ctx.linkedRoot, opts.schemaDir);
       const schemas = await deployedSchemas(ctx, project);
-      const rendered = schemas.map((s) => ({ file: join4(dir, `${s.name}.ts`), code: schemaToDsl(s) }));
+      const rendered = schemas.map((s) => ({ file: join5(dir, `${s.name}.ts`), code: schemaToDsl(s) }));
       const changed = rendered.filter(
         (r) => !existsSync4(r.file) || readFileSync3(r.file, "utf8") !== r.code
       );
@@ -2108,7 +2130,7 @@ function renderDiff(diff) {
 
 // src/content-files.ts
 import { readFile as readFile2, readdir, stat } from "fs/promises";
-import { basename as basename2, extname, join as join5 } from "path";
+import { basename as basename2, extname, join as join6 } from "path";
 async function detectFormat(path) {
   const info = await stat(path).catch(() => void 0);
   if (!info) throw new UsageError(`No such file or directory: ${path}`);
@@ -2186,7 +2208,7 @@ async function readJsonRows(file) {
 }
 async function readMarkdownRows(dir, bodyField) {
   const info = await stat(dir).catch(() => void 0);
-  const files = info?.isDirectory() ? (await readdir(dir)).filter((name) => [".md", ".markdown"].includes(extname(name).toLowerCase())).sort().map((name) => join5(dir, name)) : [dir];
+  const files = info?.isDirectory() ? (await readdir(dir)).filter((name) => [".md", ".markdown"].includes(extname(name).toLowerCase())).sort().map((name) => join6(dir, name)) : [dir];
   if (files.length === 0) throw new UsageError(`No .md files found in ${dir}`);
   const rows = [];
   for (const file of files) {
@@ -2823,6 +2845,25 @@ function registerReleases(program) {
       });
     })
   );
+  releases.command("diff").description("Show what a release changed, field by field").argument("<release>", "release number or published change set id").action(
+    handle(async (ctx, args) => {
+      const project = ctx.requireProject();
+      const release = await ctx.management().releases.get(project, args[0]);
+      const diff = await ctx.management().changeSets.diff(project, release.id);
+      emit({ release, ...diff }, () => {
+        diag(`#${release.number} \u2014 ${release.title} (${diff.items.length} item(s))`);
+        for (const item of diff.items) {
+          const name = item.collection && item.slug ? `${item.collection}/${item.slug}` : item.resourceId;
+          process.stdout.write(`  ${item.operation} ${name}
+`);
+          for (const change of item.changes) {
+            process.stdout.write(`    ${change.kind} ${change.path}
+`);
+          }
+        }
+      });
+    })
+  );
   releases.command("revert").description("Generate a change set restoring the state before a release").argument("<release>", "release number or published change set id").option("--title <title>", "title for the generated change set").option("--force", "revert resources a later release already changed", false).action(
     handle(async (ctx, args, opts) => {
       const project = ctx.requireProject();
@@ -2854,6 +2895,244 @@ function registerReleases(program) {
   );
 }
 
+// src/commands/pull.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { join as join7 } from "path";
+
+// ../sdk/dist/lock.js
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+var LOCKFILE_NAME = "myna.lock";
+function parseLock(source, origin = LOCKFILE_NAME) {
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch (error) {
+    throw new Error(`${origin} is not valid JSON: ${error.message}`);
+  }
+  const lock = parsed;
+  if (typeof lock?.project !== "string" || !lock.project) {
+    throw new Error(`${origin} is missing "project".`);
+  }
+  if (typeof lock.release !== "number" || !Number.isInteger(lock.release) || lock.release < 0) {
+    throw new Error(`${origin} is missing a non-negative integer "release".`);
+  }
+  return {
+    project: lock.project,
+    release: lock.release,
+    publishedAt: typeof lock.publishedAt === "string" ? lock.publishedAt : "",
+    ...lock.title ? { title: lock.title } : {},
+    ...lock.apiUrl ? { apiUrl: lock.apiUrl } : {}
+  };
+}
+function formatLock(lock) {
+  const ordered = {
+    project: lock.project,
+    release: lock.release,
+    publishedAt: lock.publishedAt
+  };
+  if (lock.title) ordered.title = lock.title;
+  if (lock.apiUrl) ordered.apiUrl = lock.apiUrl;
+  return `${JSON.stringify(ordered, null, 2)}
+`;
+}
+function writeLock(file, lock) {
+  writeFileSync4(file, formatLock(lock));
+}
+
+// src/commands/pull.ts
+var MAX_DETAILED_RELEASES = 20;
+function lockPath(ctx) {
+  return join7(ctx.linkedRoot ?? process.cwd(), LOCKFILE_NAME);
+}
+function readLockAt(file) {
+  if (!existsSync6(file)) return void 0;
+  return parseLock(readFileSync5(file, "utf8"), file);
+}
+async function latestRelease(ctx, project) {
+  const page = await ctx.management().releases.list(project, { limit: 1 });
+  const latest = page.data[0];
+  if (!latest) {
+    throw new CliError(
+      `Project ${project} has not published a release yet. There is nothing to pin \u2014 publish a change set first.`
+    );
+  }
+  return latest;
+}
+async function releasesBetween(ctx, project, from, to) {
+  const found = [];
+  let cursor;
+  for (; ; ) {
+    const page = await ctx.management().releases.list(project, { limit: 50, ...cursor ? { cursor } : {} });
+    for (const release of page.data) {
+      if (release.number > to) continue;
+      if (release.number <= from) return found.reverse();
+      found.push(release);
+    }
+    if (!page.nextCursor) return found.reverse();
+    cursor = page.nextCursor;
+  }
+}
+function itemLabel(item) {
+  const name = item.collection && item.slug ? `${item.collection}/${item.slug}` : item.resourceId;
+  return `${item.operation} ${name}`;
+}
+async function pullRequestBody(ctx, project, from, to, releases, rollback) {
+  const lines = [
+    !from ? `Pins \`${LOCKFILE_NAME}\` for \`${project}\` to release #${to.number}.` : rollback ? `Rolls \`${LOCKFILE_NAME}\` for \`${project}\` back from release #${from.release} to #${to.number}.` : `Moves \`${LOCKFILE_NAME}\` for \`${project}\` from release #${from.release} to #${to.number}.`,
+    "",
+    rollback ? `${releases.length} release(s) are being undone for this repository. The content itself is untouched \u2014 nothing is unpublished \u2014 this only changes which release the build reads.` : `${releases.length} release(s). The build reads content at this release, so CI on this pull request is running against exactly the content that will ship.`
+  ];
+  const detailed = releases.slice(-MAX_DETAILED_RELEASES);
+  if (detailed.length < releases.length) {
+    lines.push(
+      "",
+      `_Showing the newest ${detailed.length} of ${releases.length} releases. The remaining ${releases.length - detailed.length} are listed without field detail._`,
+      "",
+      ...releases.slice(0, releases.length - detailed.length).map((r) => `- #${r.number} \u2014 ${r.title} (${r.itemCount} item(s))`)
+    );
+  }
+  for (const release of detailed) {
+    lines.push("", `### #${release.number} \u2014 ${release.title}`);
+    if (release.description) lines.push("", release.description);
+    let diff;
+    try {
+      diff = await ctx.management().changeSets.diff(project, release.id);
+    } catch {
+      lines.push("", `_Diff unavailable; ${release.itemCount} item(s) changed._`);
+      continue;
+    }
+    for (const item of diff.items) {
+      lines.push("", `- **${itemLabel(item)}**`);
+      if (item.changeSummary) lines.push(`  - _${item.changeSummary}_`);
+      for (const change of item.changes) lines.push(`  - \`${change.path}\` ${change.kind}`);
+    }
+  }
+  return lines.join("\n");
+}
+function registerPull(program) {
+  program.command("pull").description(`Pin this repository's content to a release in ${LOCKFILE_NAME}`).option("--release <n>", "release number to pin to (default: the newest)").option("--check", "report whether the pin is behind and exit non-zero if it is", false).option("--open-pr", "commit the bump onto a branch and open a pull request", false).option(
+    "--run <command>",
+    "shell command to run after moving the pin; anything it changes is committed with the lockfile"
+  ).option("--branch <name>", "branch to use with --open-pr (default: derived from the release)").option("--base <branch>", "branch to open the pull request against (default: the current branch)").action(
+    handle(async (ctx, _args, opts) => {
+      const project = ctx.requireProject();
+      const file = lockPath(ctx);
+      const current = readLockAt(file);
+      if (current && current.project !== project) {
+        throw new UsageError(
+          `${LOCKFILE_NAME} pins project "${current.project}" but the selected project is "${project}". Pass --project ${current.project}, or delete the lockfile.`
+        );
+      }
+      const target = opts.release ? await ctx.management().releases.get(project, String(opts.release)) : await latestRelease(ctx, project);
+      if (opts.check) {
+        if (!current) {
+          throw new UsageError(`No ${LOCKFILE_NAME} here. Run \`myna pull\` to create one.`);
+        }
+        const behind = await releasesBetween(ctx, project, current.release, target.number);
+        emit(
+          { lockfile: file, release: current.release, latest: target.number, behind: behind.map((r) => r.number) },
+          () => {
+            if (behind.length === 0) {
+              diag(`${LOCKFILE_NAME} is at release #${current.release} \u2014 current.`);
+              return;
+            }
+            diag(`${LOCKFILE_NAME} is at release #${current.release}; #${target.number} is available.`);
+            table(behind, [
+              { header: "#", value: (r) => String(r.number) },
+              { header: "TITLE", value: (r) => r.title },
+              { header: "PUBLISHED", value: (r) => r.publishedAt },
+              { header: "ITEMS", value: (r) => String(r.itemCount) }
+            ]);
+          }
+        );
+        if (behind.length > 0) process.exitCode = 1;
+        return;
+      }
+      const next = {
+        project,
+        release: target.number,
+        publishedAt: target.publishedAt,
+        title: target.title,
+        ...ctx.apiUrl && !ctx.apiUrl.startsWith("https://api.myna.sh") ? { apiUrl: ctx.apiUrl } : {}
+      };
+      if (current && formatLock(current) === formatLock(next)) {
+        emit(
+          { lockfile: file, release: target.number, changed: false, pullRequest: null },
+          () => diag(`${LOCKFILE_NAME} is already at release #${target.number}.`)
+        );
+        return;
+      }
+      const rollback = current !== void 0 && target.number < current.release;
+      const releases = rollback ? await releasesBetween(ctx, project, target.number, current.release) : await releasesBetween(ctx, project, current?.release ?? 0, target.number);
+      if (!opts.openPr) {
+        writeLock(file, next);
+        if (opts.run) execSync(opts.run, { cwd: ctx.linkedRoot ?? process.cwd(), stdio: "inherit" });
+        emit(
+          {
+            lockfile: file,
+            release: target.number,
+            from: current?.release ?? null,
+            changed: true,
+            rollback,
+            releases: releases.map((r) => r.number)
+          },
+          () => {
+            if (!current) {
+              diag(`${LOCKFILE_NAME}: pinned to #${target.number}.`);
+              return;
+            }
+            diag(
+              rollback ? `${LOCKFILE_NAME}: #${current.release} \u2192 #${target.number}, rolling back ${releases.length} release(s).` : `${LOCKFILE_NAME}: #${current.release} \u2192 #${target.number} (${releases.length} release(s)).`
+            );
+          }
+        );
+        return;
+      }
+      const root = ctx.linkedRoot ?? process.cwd();
+      const command = opts.run;
+      const dirty = command ? worktreeChanges(root).map((c) => c.file) : dirtyFiles(root, [file]);
+      if (dirty.length > 0) {
+        throw new UsageError(`Commit or stash ${dirty.join(", ")} first.`);
+      }
+      const body = await pullRequestBody(ctx, project, current, target, releases, rollback);
+      writeLock(file, next);
+      if (command) {
+        try {
+          execSync(command, { cwd: root, stdio: "inherit" });
+        } catch (error) {
+          discardChanges(root, worktreeChanges(root));
+          throw new CliError(`--run command failed: ${error.message}`);
+        }
+      }
+      const changes = worktreeChanges(root);
+      const branch = opts.branch ?? branchForRelease(project, target.number);
+      let result;
+      try {
+        result = openPullRequest({
+          cwd: root,
+          files: changes.map((c) => c.file),
+          branch,
+          base: opts.base,
+          title: rollback ? `chore(content): roll ${project} back to release #${target.number}` : `chore(content): ${project} release #${target.number} \u2014 ${target.title}`,
+          body
+        });
+      } catch (error) {
+        discardChanges(root, changes);
+        throw error;
+      }
+      if (!result.opened) discardChanges(root, changes);
+      emit({ lockfile: file, release: target.number, from: current?.release ?? null, releases: releases.map((r) => r.number), pullRequest: result }, () => {
+        if (!result.opened) {
+          diag(`Branch ${result.branch} already exists \u2014 release #${target.number} is already proposed.`);
+          return;
+        }
+        diag(`Opened ${result.url ?? `pull request from ${result.branch}`} against ${result.base}.`);
+      });
+    })
+  );
+}
+
 // src/commands/previews.ts
 function previewTarget(ref) {
   if (ref.startsWith("chs_")) return { changeSetId: ref };
@@ -3698,8 +3977,8 @@ function registerBilling(program) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join8 } from "path";
 
 // src/registry.ts
 var NPM_REGISTRY = "https://registry.npmjs.org";
@@ -3738,7 +4017,7 @@ function installCommand(manager, version) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.11.0" : "0.0.0-dev";
+var VERSION = true ? "0.12.0" : "0.0.0-dev";
 var IS_RELEASE_BUILD = true;
 
 // src/commands/doctor.ts
@@ -3912,7 +4191,7 @@ async function checkOrigin(ctx, origin) {
 }
 async function checkSchema(ctx, schemaDir) {
   const dir = schemaDirFor(ctx.linkedRoot, schemaDir);
-  if (!existsSync5(dir)) {
+  if (!existsSync7(dir)) {
     return check("schema.drift", "Local schema", "skip", `No schema directory at ${dir}.`);
   }
   if (!ctx.project) {
@@ -3962,7 +4241,7 @@ function findGeneratedTypes(root, depth = 4) {
   const dirs = [];
   for (const entry of entries) {
     if (SCAN_IGNORE.has(entry) || entry.startsWith(".")) continue;
-    const full = join6(root, entry);
+    const full = join8(root, entry);
     let stats;
     try {
       stats = statSync2(full);
@@ -3975,7 +4254,7 @@ function findGeneratedTypes(root, depth = 4) {
     }
     if (!/\.(ts|d\.ts)$/.test(entry)) continue;
     try {
-      if (looksGenerated(readFileSync4(full, "utf8"))) return full;
+      if (looksGenerated(readFileSync6(full, "utf8"))) return full;
     } catch {
     }
   }
@@ -3992,16 +4271,16 @@ async function checkTypes(ctx, explicit, schemaDir) {
   if (!file) {
     return check("types.freshness", "Generated types", "skip", "No generated types file found.");
   }
-  if (!existsSync5(file)) {
+  if (!existsSync7(file)) {
     return check("types.freshness", "Generated types", "fail", `${file} does not exist.`);
   }
   const dir = schemaDirFor(ctx.linkedRoot, schemaDir);
-  if (!existsSync5(dir)) {
+  if (!existsSync7(dir)) {
     return check("types.freshness", "Generated types", "skip", `Found ${file} but no schema directory to compare against.`);
   }
   try {
     const expected = generateTypesModule(await loadLocalSchemas(dir));
-    return readFileSync4(file, "utf8") === expected ? check("types.freshness", "Generated types", "pass", `${file} matches the local schema.`) : check(
+    return readFileSync6(file, "utf8") === expected ? check("types.freshness", "Generated types", "pass", `${file} matches the local schema.`) : check(
       "types.freshness",
       "Generated types",
       "warn",
@@ -4117,7 +4396,7 @@ function registerUpdate(program) {
 
 // src/commands/sync.ts
 import { readdir as readdir2, stat as stat2 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join9 } from "path";
 async function isDirectory(path) {
   const info = await stat2(path).catch(() => void 0);
   return Boolean(info?.isDirectory());
@@ -4132,7 +4411,7 @@ async function planDirectories(dir, collection) {
   const plan = [];
   for (const name of children.sort()) {
     if (name.startsWith(".")) continue;
-    const full = join7(dir, name);
+    const full = join9(dir, name);
     if (await isDirectory(full)) plan.push({ collection: name, path: full });
   }
   if (plan.length === 0) {
@@ -4303,6 +4582,7 @@ function buildProgram() {
   registerSync(program);
   registerChanges(program);
   registerReleases(program);
+  registerPull(program);
   registerPreviews(program);
   registerAssets(program);
   registerAdmin(program);