@myna-sh/cli 0.11.0 → 0.12.1

package/dist/main.js

@@ -90,9 +90,9 @@ function buildQuery(query) {
   return qs ? `?${qs}` : "";
 }
 function sleep(ms, signal) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     if (signal?.aborted) return reject(signal.reason ?? new Error("Aborted"));
-    const timer = setTimeout(resolve3, ms);
+    const timer = setTimeout(resolve4, ms);
     signal?.addEventListener(
       "abort",
       () => {
@@ -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,23 @@ function branchForContent(contents) {
   const digest = createHash2("sha256").update(contents.join("\0")).digest("hex").slice(0, 8);
   return `myna/schema-${digest}`;
 }
+function branchExists(cwd, branch) {
+  try {
+    execFileSync2("git", ["rev-parse", "--verify", `refs/heads/${branch}`], { cwd, stdio: "ignore" });
+    return true;
+  } catch {
+  }
+  try {
+    const out = execFileSync2("git", ["ls-remote", "--heads", "origin", branch], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return out.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
 function openPullRequest(input) {
   if (!available("git")) throw new CliError("git is required to open a pull request.");
   if (!available("gh")) {
@@ -1811,18 +1830,9 @@ function openPullRequest(input) {
   if (base === "HEAD") {
     throw new CliError("HEAD is detached; pass --base to say which branch to open the pull request against.");
   }
-  const exists = (() => {
-    try {
-      execFileSync2("git", ["rev-parse", "--verify", `refs/heads/${input.branch}`], {
-        cwd: input.cwd,
-        stdio: "ignore"
-      });
-      return true;
-    } catch {
-      return false;
-    }
-  })();
-  if (exists) return { opened: false, branch: input.branch, base, url: null, reason: "branch-exists" };
+  if (branchExists(input.cwd, input.branch)) {
+    return { opened: false, branch: input.branch, base, url: null, reason: "branch-exists" };
+  }
   git(["checkout", "-b", input.branch], input.cwd);
   let pushed = false;
   try {
@@ -1848,6 +1858,44 @@ 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) {
+  try {
+    return execFileSync2("git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return void 0;
+  }
+}
+function trackedLockfiles(cwd) {
+  const root = repositoryRoot(cwd);
+  if (!root) return [];
+  try {
+    return execFileSync2("git", ["ls-files", "--full-name", "*myna.lock", "myna.lock"], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).split("\n").filter(Boolean).map((f) => join4(root, f));
+  } catch {
+    return [];
+  }
+}
+function worktreeChanges(cwd) {
+  const root = repositoryRoot(cwd);
+  if (!root) throw new CliError(`${cwd} is not inside a git repository.`);
+  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 +1947,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 +2156,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 +2234,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 +2871,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 +2921,439 @@ function registerReleases(program) {
   );
 }
 
+// src/commands/pull.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { join as join8 } from "path";
+
+// ../sdk/dist/lock.js
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname2, join as join7, resolve as resolve3 } from "path";
+var LOCKFILE_NAME = "myna.lock";
+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 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 } : {}
+  };
+}
+var LOCKFILE_NAME2 = "myna.lock";
+function formatLock2(lock) {
+  return formatLock(lock);
+}
+function parseLock2(source, origin = LOCKFILE_NAME2) {
+  return parseLock(source, origin);
+}
+function findLockfile(startDir = process.cwd()) {
+  let dir = resolve3(startDir);
+  for (; ; ) {
+    const file = join7(dir, LOCKFILE_NAME2);
+    if (existsSync5(file)) return file;
+    const parent = dirname2(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function writeLock(file, lock) {
+  writeFileSync4(file, formatLock2(lock));
+}
+
+// ../shared/dist/ids.js
+var ID_PREFIXES = {
+  user: "usr",
+  oauthAccount: "oau",
+  session: "ses",
+  organization: "org",
+  organizationMember: "mem",
+  organizationInvitation: "inv",
+  project: "prj",
+  projectOrigin: "por",
+  apiKey: "key",
+  collection: "col",
+  collectionVersion: "clv",
+  entry: "ent",
+  entrySlugAlias: "als",
+  entryRevision: "rev",
+  changeSet: "chs",
+  changeSetItem: "csi",
+  changeSetReview: "csr",
+  changeSetComment: "csc",
+  changeSetCheck: "chk",
+  projectCheck: "pck",
+  asset: "ast",
+  assetUpload: "upl",
+  savedView: "viw",
+  previewToken: "prv",
+  webhookEndpoint: "whk",
+  webhookEvent: "whe",
+  webhookDelivery: "whd",
+  auditEvent: "aud",
+  job: "job",
+  idempotencyKey: "idm",
+  billingCustomer: "bcu",
+  billingSubscription: "bsu",
+  billingProviderEvent: "evt",
+  usagePeriod: "usp",
+  mcpClient: "mcl",
+  mcpGrant: "mgr",
+  mcpAuthorizationCode: "mac",
+  mcpToken: "mtk",
+  deviceAuthorization: "dev",
+  githubInstallation: "ghi",
+  projectRepository: "prp"
+};
+var PREFIX_SET = new Set(Object.values(ID_PREFIXES));
+
+// ../shared/dist/dates.js
+var HOURS = 60 * 60;
+var DAYS = 24 * 60 * 60;
+
+// ../shared/dist/origins.js
+function normalizeOrigin(value) {
+  try {
+    const url = new URL(value.trim());
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+      return void 0;
+    return url.origin;
+  } catch {
+    return void 0;
+  }
+}
+
+// ../shared/dist/plans.js
+var GB = 1024 ** 3;
+var MB = 1024 ** 2;
+var UNLIMITED = Number.MAX_SAFE_INTEGER;
+var PLANS = {
+  free: {
+    key: "free",
+    priceEurMonthly: 0,
+    priceEurYearly: 0,
+    maxProjects: 2,
+    maxMembers: 2,
+    storageBytes: 1 * GB,
+    monthlyBandwidthBytes: 25 * GB,
+    monthlyPublicApiRequests: 1e4,
+    maxWebhookEndpoints: 1,
+    revisionRetentionDays: 30,
+    maxUploadBytes: 50 * MB
+  },
+  pro: {
+    key: "pro",
+    priceEurMonthly: 9,
+    priceEurYearly: 90,
+    maxProjects: 10,
+    maxMembers: 5,
+    storageBytes: 10 * GB,
+    monthlyBandwidthBytes: 250 * GB,
+    monthlyPublicApiRequests: 5e5,
+    maxWebhookEndpoints: 10,
+    revisionRetentionDays: null,
+    maxUploadBytes: 250 * MB
+  },
+  /**
+   * Myna's own organizations — the changelog, and anything else we run on the
+   * product we sell. It is never sold, never offered at checkout, and cannot be
+   * reached through the API: `scripts/bootstrap-internal-org.mjs` writes it
+   * directly, and billing refuses to move an organization on or off it.
+   */
+  internal: {
+    key: "internal",
+    priceEurMonthly: 0,
+    priceEurYearly: null,
+    maxProjects: UNLIMITED,
+    maxMembers: UNLIMITED,
+    storageBytes: UNLIMITED,
+    monthlyBandwidthBytes: UNLIMITED,
+    monthlyPublicApiRequests: UNLIMITED,
+    maxWebhookEndpoints: UNLIMITED,
+    revisionRetentionDays: null,
+    maxUploadBytes: UNLIMITED
+  }
+};
+
+// ../shared/dist/rank.js
+var DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var MIN_DIGIT = DIGITS[0];
+var LAST_INDEX = DIGITS.length - 1;
+var MID_DIGIT = DIGITS[Math.floor(DIGITS.length / 2)];
+
+// ../shared/dist/release.js
+function parseSemVer(version) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version.trim());
+  if (!match)
+    return void 0;
+  return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]) };
+}
+function compareSemVer(a, b) {
+  const left = parseSemVer(a);
+  const right = parseSemVer(b);
+  if (!left || !right)
+    throw new Error(`Cannot compare versions "${a}" and "${b}".`);
+  return left.major - right.major || left.minor - right.minor || left.patch - right.patch;
+}
+
+// ../shared/dist/lock.js
+var LOCKFILE_NAME3 = "myna.lock";
+function branchForRelease(project, release) {
+  const slug = project.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "project";
+  return `myna/content-${slug}-r${release}`;
+}
+var MAX_DETAILED_RELEASES = 20;
+function releasePullRequestTitle(input) {
+  return input.rollback ? `chore(content): roll ${input.project} back to release #${input.to.number}` : `chore(content): ${input.project} release #${input.to.number} \u2014 ${input.to.title}`;
+}
+function releasePullRequestBody(input) {
+  const { project, from, to, releases, rollback } = input;
+  const lines = [
+    from === null ? `Pins \`${LOCKFILE_NAME3}\` for \`${project}\` to release #${to.number}.` : rollback ? `Rolls \`${LOCKFILE_NAME3}\` for \`${project}\` back from release #${from} to #${to.number}.` : `Moves \`${LOCKFILE_NAME3}\` for \`${project}\` from release #${from} 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) {
+    const omitted = releases.length - detailed.length;
+    lines.push("", `_Showing the newest ${detailed.length} of ${releases.length} releases. The remaining ${omitted} are listed without field detail._`, "", ...releases.slice(0, omitted).map((r) => `- #${r.number} \u2014 ${r.title} (${r.itemCount ?? 0} item(s))`));
+  }
+  for (const release of detailed) {
+    lines.push("", `### #${release.number} \u2014 ${release.title}`);
+    if (release.description)
+      lines.push("", release.description);
+    if (!release.diff) {
+      lines.push("", `_Diff unavailable; ${release.itemCount ?? 0} item(s) changed._`);
+      continue;
+    }
+    for (const item of release.diff.items) {
+      const name = item.collection && item.slug ? `${item.collection}/${item.slug}` : item.resourceId;
+      lines.push("", `- **${item.operation} ${name}**`);
+      if (item.changeSummary)
+        lines.push(`  - _${item.changeSummary}_`);
+      for (const change of item.changes)
+        lines.push(`  - \`${change.path}\` ${change.kind}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/commands/pull.ts
+function lockPath(ctx) {
+  const cwd = ctx.linkedRoot ?? process.cwd();
+  const found = findLockfile(cwd);
+  if (found) {
+    const boundary = repositoryRoot(cwd);
+    if (!boundary || found.startsWith(boundary)) return found;
+  }
+  return join8(cwd, LOCKFILE_NAME2);
+}
+function assertOneLockfile(cwd, active) {
+  const all = trackedLockfiles(cwd);
+  if (all.length <= 1) return;
+  throw new UsageError(
+    `This repository has ${all.length} lockfiles:
+` + all.map((f) => `  ${f}${f === active ? "  (the one this would move)" : ""}`).join("\n") + `
+Reads take the one nearest the build, which may not be that one. Delete the extras and keep a single ${LOCKFILE_NAME2}.`
+  );
+}
+function readLockAt(file) {
+  if (!existsSync6(file)) return void 0;
+  return parseLock2(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;
+  }
+}
+async function pullRequestText(ctx, project, from, to, releases, rollback) {
+  const summaries = await Promise.all(
+    releases.map(async (release) => ({
+      number: release.number,
+      title: release.title,
+      description: release.description,
+      itemCount: release.itemCount,
+      // A release whose diff cannot be read is still a release worth naming.
+      diff: await ctx.management().changeSets.diff(project, release.id).catch(() => null)
+    }))
+  );
+  const input = {
+    project,
+    from: from?.release ?? null,
+    to: { number: to.number, title: to.title, description: to.description, itemCount: to.itemCount },
+    releases: summaries,
+    rollback
+  };
+  return { title: releasePullRequestTitle(input), body: releasePullRequestBody(input) };
+}
+function registerPull(program) {
+  program.command("pull").description(`Pin this repository's content to a release in ${LOCKFILE_NAME2}`).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);
+      assertOneLockfile(ctx.linkedRoot ?? process.cwd(), file);
+      const current = readLockAt(file);
+      if (current && current.project !== project) {
+        throw new UsageError(
+          `${LOCKFILE_NAME2} 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_NAME2} 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_NAME2} is at release #${current.release} \u2014 current.`);
+              return;
+            }
+            diag(`${LOCKFILE_NAME2} 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 && formatLock2(current) === formatLock2(next)) {
+        emit(
+          { lockfile: file, release: target.number, changed: false, pullRequest: null },
+          () => diag(`${LOCKFILE_NAME2} 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_NAME2}: pinned to #${target.number}.`);
+              return;
+            }
+            diag(
+              rollback ? `${LOCKFILE_NAME2}: #${current.release} \u2192 #${target.number}, rolling back ${releases.length} release(s).` : `${LOCKFILE_NAME2}: #${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 text = await pullRequestText(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: text.title,
+          body: text.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 };
@@ -3024,139 +3524,6 @@ function registerAssets(program) {
   );
 }
 
-// ../shared/dist/ids.js
-var ID_PREFIXES = {
-  user: "usr",
-  oauthAccount: "oau",
-  session: "ses",
-  organization: "org",
-  organizationMember: "mem",
-  organizationInvitation: "inv",
-  project: "prj",
-  projectOrigin: "por",
-  apiKey: "key",
-  collection: "col",
-  collectionVersion: "clv",
-  entry: "ent",
-  entrySlugAlias: "als",
-  entryRevision: "rev",
-  changeSet: "chs",
-  changeSetItem: "csi",
-  changeSetReview: "csr",
-  changeSetComment: "csc",
-  changeSetCheck: "chk",
-  projectCheck: "pck",
-  asset: "ast",
-  assetUpload: "upl",
-  savedView: "viw",
-  previewToken: "prv",
-  webhookEndpoint: "whk",
-  webhookEvent: "whe",
-  webhookDelivery: "whd",
-  auditEvent: "aud",
-  job: "job",
-  idempotencyKey: "idm",
-  billingCustomer: "bcu",
-  billingSubscription: "bsu",
-  billingProviderEvent: "evt",
-  usagePeriod: "usp",
-  mcpClient: "mcl",
-  mcpGrant: "mgr",
-  mcpAuthorizationCode: "mac",
-  mcpToken: "mtk",
-  deviceAuthorization: "dev"
-};
-var PREFIX_SET = new Set(Object.values(ID_PREFIXES));
-
-// ../shared/dist/dates.js
-var HOURS = 60 * 60;
-var DAYS = 24 * 60 * 60;
-
-// ../shared/dist/origins.js
-function normalizeOrigin(value) {
-  try {
-    const url = new URL(value.trim());
-    if (url.protocol !== "http:" && url.protocol !== "https:")
-      return void 0;
-    return url.origin;
-  } catch {
-    return void 0;
-  }
-}
-
-// ../shared/dist/plans.js
-var GB = 1024 ** 3;
-var MB = 1024 ** 2;
-var UNLIMITED = Number.MAX_SAFE_INTEGER;
-var PLANS = {
-  free: {
-    key: "free",
-    priceEurMonthly: 0,
-    priceEurYearly: 0,
-    maxProjects: 2,
-    maxMembers: 2,
-    storageBytes: 1 * GB,
-    monthlyBandwidthBytes: 25 * GB,
-    monthlyPublicApiRequests: 1e4,
-    maxWebhookEndpoints: 1,
-    revisionRetentionDays: 30,
-    maxUploadBytes: 50 * MB
-  },
-  pro: {
-    key: "pro",
-    priceEurMonthly: 9,
-    priceEurYearly: 90,
-    maxProjects: 10,
-    maxMembers: 5,
-    storageBytes: 10 * GB,
-    monthlyBandwidthBytes: 250 * GB,
-    monthlyPublicApiRequests: 5e5,
-    maxWebhookEndpoints: 10,
-    revisionRetentionDays: null,
-    maxUploadBytes: 250 * MB
-  },
-  /**
-   * Myna's own organizations — the changelog, and anything else we run on the
-   * product we sell. It is never sold, never offered at checkout, and cannot be
-   * reached through the API: `scripts/bootstrap-internal-org.mjs` writes it
-   * directly, and billing refuses to move an organization on or off it.
-   */
-  internal: {
-    key: "internal",
-    priceEurMonthly: 0,
-    priceEurYearly: null,
-    maxProjects: UNLIMITED,
-    maxMembers: UNLIMITED,
-    storageBytes: UNLIMITED,
-    monthlyBandwidthBytes: UNLIMITED,
-    monthlyPublicApiRequests: UNLIMITED,
-    maxWebhookEndpoints: UNLIMITED,
-    revisionRetentionDays: null,
-    maxUploadBytes: UNLIMITED
-  }
-};
-
-// ../shared/dist/rank.js
-var DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-var MIN_DIGIT = DIGITS[0];
-var LAST_INDEX = DIGITS.length - 1;
-var MID_DIGIT = DIGITS[Math.floor(DIGITS.length / 2)];
-
-// ../shared/dist/release.js
-function parseSemVer(version) {
-  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version.trim());
-  if (!match)
-    return void 0;
-  return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]) };
-}
-function compareSemVer(a, b) {
-  const left = parseSemVer(a);
-  const right = parseSemVer(b);
-  if (!left || !right)
-    throw new Error(`Cannot compare versions "${a}" and "${b}".`);
-  return left.major - right.major || left.minor - right.minor || left.patch - right.patch;
-}
-
 // src/commands/admin.ts
 function csv(value) {
   return value.split(",").map((s) => s.trim()).filter(Boolean);
@@ -3698,8 +4065,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 join9 } from "path";
 
 // src/registry.ts
 var NPM_REGISTRY = "https://registry.npmjs.org";
@@ -3738,7 +4105,7 @@ function installCommand(manager, version) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.11.0" : "0.0.0-dev";
+var VERSION = true ? "0.12.1" : "0.0.0-dev";
 var IS_RELEASE_BUILD = true;
 
 // src/commands/doctor.ts
@@ -3912,7 +4279,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 +4329,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 = join9(root, entry);
     let stats;
     try {
       stats = statSync2(full);
@@ -3975,7 +4342,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 +4359,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 +4484,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 join10 } from "path";
 async function isDirectory(path) {
   const info = await stat2(path).catch(() => void 0);
   return Boolean(info?.isDirectory());
@@ -4132,7 +4499,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 = join10(dir, name);
     if (await isDirectory(full)) plan.push({ collection: name, path: full });
   }
   if (plan.length === 0) {
@@ -4303,6 +4670,7 @@ function buildProgram() {
   registerSync(program);
   registerChanges(program);
   registerReleases(program);
+  registerPull(program);
   registerPreviews(program);
   registerAssets(program);
   registerAdmin(program);