@stacksjs/actions 0.70.88 → 0.70.91

package/dist/upgrade/framework-utils.js

@@ -0,0 +1,193 @@
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import process from "node:process";
+export function resolveUpgradeContext(options, currentChannel) {
+  const targetVersion = options.version;
+  if (targetVersion)
+    return { channel: "stable", ref: targetVersion.startsWith("v") ? targetVersion : `v${targetVersion}`, targetVersion };
+  if (options.canary)
+    return { channel: "canary", ref: "main" };
+  if (options.stable)
+    return { channel: "stable", ref: "stable" };
+  if (currentChannel === "canary")
+    return { channel: "canary", ref: "main" };
+  return { channel: "stable", ref: "stable" };
+}
+export function buildTemplateString(ref, subPath = "storage/framework/core") {
+  return `github:stacksjs/stacks#${ref}/${subPath}`;
+}
+export function readVersion(pkgPath) {
+  try {
+    if (existsSync(pkgPath))
+      return JSON.parse(readFileSync(pkgPath, "utf-8")).version || null;
+  } catch {}
+  return null;
+}
+export function readChannel(channelFilePath) {
+  try {
+    if (existsSync(channelFilePath)) {
+      if (readFileSync(channelFilePath, "utf-8").trim() === "canary")
+        return "canary";
+    }
+  } catch {}
+  return "stable";
+}
+export function writeChannel(channelFilePath, ch) {
+  try {
+    writeFileSync(channelFilePath, ch, "utf-8");
+  } catch {}
+}
+export function readSyncedVersion(versionFilePath) {
+  try {
+    if (existsSync(versionFilePath)) {
+      const content = readFileSync(versionFilePath, "utf-8").trim(), [ch, sha] = content.split(/\s+/);
+      if ((ch === "stable" || ch === "canary") && sha && /^[0-9a-f]{40}$/i.test(sha))
+        return { channel: ch, sha: sha.toLowerCase() };
+    }
+  } catch {}
+  return null;
+}
+export function writeSyncedVersion(versionFilePath, ch, sha) {
+  try {
+    writeFileSync(versionFilePath, `${ch} ${sha}`, "utf-8");
+  } catch {}
+}
+export function shouldShortCircuit(args) {
+  const { force, targetVersion, remoteSha, synced, channel } = args;
+  if (force || targetVersion)
+    return !1;
+  if (!remoteSha || !synced)
+    return !1;
+  return synced.channel === channel && synced.sha === remoteSha.toLowerCase();
+}
+export function resolveUpgradeMessage(ctx, currentChannel, isStableFlag) {
+  if (ctx.targetVersion)
+    return `Installing Stacks v${ctx.targetVersion.replace(/^v/, "")}...`;
+  if (ctx.channel === "canary")
+    return "Upgrading to the latest canary build...";
+  if (isStableFlag && currentChannel === "canary")
+    return "Switching back to the latest stable release...";
+  return "Upgrading to the latest version...";
+}
+export function resolveSuccessMessage(ctx, currentVersion, newVersion, currentChannel, force) {
+  if (ctx.targetVersion) {
+    const pinned = ctx.targetVersion.replace(/^v/, "");
+    if (currentVersion === pinned && !force)
+      return `Stacks is already at v${pinned}`;
+    if (currentVersion)
+      return `Installed Stacks v${pinned} (was v${currentVersion})`;
+    return `Installed Stacks v${pinned}`;
+  }
+  if (currentVersion && newVersion && currentVersion === newVersion && !force) {
+    if (ctx.channel === "canary")
+      return `Stacks is already up to date (canary ${currentVersion})`;
+    return `Stacks is already up to date (v${currentVersion})`;
+  }
+  if (currentVersion && newVersion) {
+    const from = currentChannel === "canary" ? `canary ${currentVersion}` : `v${currentVersion}`, to = ctx.channel === "canary" ? `canary ${newVersion}` : `v${newVersion}`;
+    return `Upgraded Stacks from ${from} to ${to}`;
+  }
+  if (newVersion)
+    return `Upgraded Stacks to ${ctx.channel === "canary" ? `canary ${newVersion}` : `v${newVersion}`}`;
+  return `Upgraded Stacks to ${ctx.ref} (latest)`;
+}
+export const MANAGED_PATHS = [
+  {
+    localPath: "storage/framework/core",
+    subPath: "storage/framework/core",
+    label: "core",
+    skip: ["node_modules", "dist", "bun.lock", ".DS_Store"]
+  },
+  {
+    localPath: "storage/framework/defaults",
+    subPath: "storage/framework/defaults",
+    label: "defaults",
+    skip: ["node_modules", "dist", ".DS_Store", ".discovered-models.json"]
+  },
+  { localPath: "buddy", subPath: "buddy", label: "buddy", isFile: !0 },
+  { localPath: "bootstrap", subPath: "bootstrap", label: "bootstrap", isFile: !0 }
+];
+export function detectLocalStacks(projectRoot) {
+  const candidates = [
+    process.env.STACKS_LOCAL_PATH,
+    resolve(projectRoot, "..", "stacks"),
+    resolve(projectRoot, "..", "..", "stacks"),
+    resolve(homedir(), "Code", "stacks"),
+    resolve(homedir(), "code", "stacks"),
+    resolve(homedir(), "projects", "stacks"),
+    resolve(homedir(), "src", "stacks")
+  ];
+  for (const candidate of candidates) {
+    if (!candidate)
+      continue;
+    const marker = join(candidate, "storage", "framework", "core", "buddy", "package.json");
+    try {
+      if (existsSync(marker) && resolve(candidate) !== resolve(projectRoot))
+        return resolve(candidate);
+    } catch {}
+  }
+  return null;
+}
+export async function snapshotTree(root, skip = []) {
+  const out = new Map;
+  if (!existsSync(root))
+    return out;
+  const skipSet = new Set(skip), stack = [{ abs: root, rel: "" }], hashJobs = [];
+  while (stack.length > 0) {
+    const { abs, rel } = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(abs);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      if (skipSet.has(name))
+        continue;
+      const childAbs = join(abs, name), childRel = rel ? `${rel}/${name}` : name;
+      let info;
+      try {
+        info = statSync(childAbs);
+      } catch {
+        continue;
+      }
+      if (info.isDirectory())
+        stack.push({ abs: childAbs, rel: childRel });
+      else if (info.isFile()) {
+        const size = info.size;
+        hashJobs.push((async () => {
+          const hash = await hashFile(childAbs);
+          out.set(childRel, { size, hash });
+        })());
+      }
+    }
+  }
+  await Promise.all(hashJobs);
+  return out;
+}
+export function diffSnapshots(before, after) {
+  let added = 0, changed = 0, unchanged = 0;
+  for (const [rel, info] of after) {
+    const prev = before.get(rel);
+    if (!prev)
+      added++;
+    else if (prev.size !== info.size || prev.hash !== info.hash)
+      changed++;
+    else
+      unchanged++;
+  }
+  let removed = 0;
+  for (const rel of before.keys())
+    if (!after.has(rel))
+      removed++;
+  return { added, changed, removed, unchanged };
+}
+async function hashFile(absPath) {
+  try {
+    const buf = await Bun.file(absPath).arrayBuffer();
+    return Bun.hash(buf);
+  } catch {
+    return 0n;
+  }
+}

package/dist/upgrade/framework.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/upgrade/framework.js

@@ -0,0 +1,310 @@
+import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { dirname, join } from "node:path";
+import process from "node:process";
+import { parseOptions } from "@stacksjs/cli";
+import { downloadTemplate } from "@stacksjs/gitit";
+import { path as p } from "@stacksjs/path";
+import { ExitCode } from "@stacksjs/types";
+import {
+  buildTemplateString,
+  detectLocalStacks,
+  diffSnapshots,
+  MANAGED_PATHS,
+  readChannel,
+  readSyncedVersion,
+  readVersion,
+  resolveSuccessMessage,
+  resolveUpgradeContext,
+  resolveUpgradeMessage,
+  shouldShortCircuit,
+  snapshotTree,
+  writeChannel,
+  writeSyncedVersion
+} from "./framework-utils";
+const options = parseOptions(), projectRoot = p.projectPath();
+if (!existsSync(p.projectPath("storage/framework/core"))) {
+  const { upgradeStacksPackages } = await import("./packages");
+  await upgradeStacksPackages(projectRoot, {
+    version: options.version,
+    canary: options.canary,
+    stable: options.stable,
+    force: options.force,
+    dryRun: options.dryRun,
+    noPostinstall: options.noPostinstall ?? options.postinstall === !1
+  });
+}
+const channelFile = join(projectRoot, ".stacks-channel"), versionFile = join(projectRoot, ".stacks-version"), currentChannel = readChannel(channelFile), ctx = resolveUpgradeContext(options, currentChannel), corePkgPath = p.projectPath("storage/framework/core/buddy/package.json"), currentVersion = readVersion(corePkgPath), explicitLocal = options.from ? p.projectPath(options.from) : null, detectedLocal = explicitLocal ?? detectLocalStacks(projectRoot), usingLocal = !!detectedLocal;
+console.log(resolveUpgradeMessage(ctx, currentChannel, !!options.stable));
+console.log(usingLocal ? `  source: local checkout at ${detectedLocal}` : `  source: github:stacksjs/stacks#${ctx.ref}`);
+if (!options.force) {
+  const dirty = await detectDirtyManagedPaths(projectRoot);
+  if (dirty.length > 0) {
+    console.warn(`
+\u26A0 The following framework-managed paths have uncommitted changes:`);
+    for (const path of dirty)
+      console.warn(`    - ${path}`);
+    console.warn(`
+  Aborting to avoid clobbering your edits.`);
+    console.warn(`  Re-run with --force to overwrite, or commit / stash the changes first.
+`);
+    process.exit(ExitCode.FatalError);
+  }
+}
+let resolvedRemoteSha = null;
+if (!options.force && !ctx.targetVersion) {
+  resolvedRemoteSha = await getRemoteSha(ctx, usingLocal, detectedLocal);
+  const synced = readSyncedVersion(versionFile);
+  if (shouldShortCircuit({ force: !!options.force, targetVersion: ctx.targetVersion, remoteSha: resolvedRemoteSha, synced, channel: ctx.channel })) {
+    console.log(`\u2714 Already on the latest ${ctx.channel} (${resolvedRemoteSha.slice(0, 7)}).`);
+    process.exit(ExitCode.Success);
+  }
+}
+const ownPath = p.frameworkPath("core/actions/src/upgrade/framework.ts"), ownHashBefore = await hashFileOrZero(ownPath), aggregate = { added: 0, changed: 0, removed: 0, unchanged: 0 }, perPath = [];
+try {
+  for (const managed of MANAGED_PATHS) {
+    const localTarget = join(projectRoot, managed.localPath), before = managed.isFile ? await singleFileSnapshot(localTarget) : await snapshotTree(localTarget, managed.skip);
+    if (usingLocal && detectedLocal)
+      await syncFromLocal(detectedLocal, managed, localTarget);
+    else {
+      if (managed.isFile)
+        continue;
+      await syncFromGitHub(ctx.ref, managed, localTarget, !!options.force);
+    }
+    const after = managed.isFile ? await singleFileSnapshot(localTarget) : await snapshotTree(localTarget, managed.skip), summary = diffSnapshots(before, after);
+    aggregate.added += summary.added;
+    aggregate.changed += summary.changed;
+    aggregate.removed += summary.removed;
+    aggregate.unchanged += summary.unchanged;
+    perPath.push({ managed, summary });
+  }
+  if (!usingLocal)
+    await syncRootFilesFromGitHub(ctx.ref);
+} catch (err) {
+  console.error("\u2718 Failed to upgrade Stacks framework:", err?.message || err);
+  process.exit(ExitCode.FatalError);
+}
+const newVersion = readVersion(corePkgPath), ownHashAfter = await hashFileOrZero(ownPath), alreadyRestarted = process.argv.includes("--__restarted");
+if (ownHashBefore !== 0n && ownHashAfter !== 0n && ownHashBefore !== ownHashAfter && !alreadyRestarted) {
+  console.log(`Upgrade pulled a newer version of the upgrade action \u2014 re-running once to pick up new sync paths and hooks.
+`);
+  const args = process.argv.slice(2).filter((a) => a !== "--__restarted"), code = await Bun.spawn({
+    cmd: [process.argv[0] || "bun", ownPath, ...args, "--__restarted"],
+    cwd: projectRoot,
+    stdout: "inherit",
+    stderr: "inherit"
+  }).exited;
+  process.exit(code ?? 0);
+}
+if (!ctx.targetVersion) {
+  writeChannel(channelFile, ctx.channel);
+  if (!resolvedRemoteSha)
+    resolvedRemoteSha = await getRemoteSha(ctx, usingLocal, detectedLocal);
+  if (resolvedRemoteSha)
+    writeSyncedVersion(versionFile, ctx.channel, resolvedRemoteSha);
+}
+console.log(`\u2714 ${resolveSuccessMessage(ctx, currentVersion, newVersion, currentChannel, !!options.force)}`);
+console.log("Sync summary:");
+for (const { managed, summary } of perPath)
+  if (managed.isFile) {
+    const moved = summary.added + summary.changed > 0;
+    console.log(`  ${managed.label.padEnd(10)} ${moved ? "updated" : "unchanged"}`);
+  } else if (summary.added + summary.changed + summary.removed === 0)
+    console.log(`  ${managed.label.padEnd(10)} unchanged (${summary.unchanged} files)`);
+  else
+    console.log(`  ${managed.label.padEnd(10)} +${summary.added} ~${summary.changed} -${summary.removed} (${summary.unchanged} unchanged)`);
+const runHooks = !options.noPostinstall && options.postinstall !== !1;
+if (runHooks)
+  await runPostSyncHooks({ aggregate, perPath, projectRoot });
+if (ctx.channel === "canary" && !ctx.targetVersion)
+  console.warn("\u26A0 Canary builds may contain bugs or breaking changes. Not recommended for production.");
+process.exit(ExitCode.Success);
+async function detectDirtyManagedPaths(root) {
+  const gitDir = join(root, ".git");
+  if (!existsSync(gitDir))
+    return [];
+  try {
+    const proc = Bun.spawn({
+      cmd: ["git", "-C", root, "status", "--porcelain", "--", ...MANAGED_PATHS.map((m) => m.localPath)],
+      stdout: "pipe",
+      stderr: "pipe"
+    }), output = await new Response(proc.stdout).text();
+    await proc.exited;
+    return output.split(`
+`).filter((line) => line.length > 0).map((line) => line.slice(3));
+  } catch {
+    return [];
+  }
+}
+async function getRemoteSha(context, fromLocal, stacksRoot) {
+  const SHA_RE = /^[0-9a-f]{40}$/i;
+  try {
+    if (fromLocal && stacksRoot) {
+      const proc = Bun.spawn({
+        cmd: ["git", "-C", stacksRoot, "rev-parse", context.ref],
+        stdout: "pipe",
+        stderr: "pipe"
+      }), out = (await new Response(proc.stdout).text()).trim();
+      if (await proc.exited === 0 && SHA_RE.test(out))
+        return out.toLowerCase();
+      const head = Bun.spawn({
+        cmd: ["git", "-C", stacksRoot, "rev-parse", "HEAD"],
+        stdout: "pipe",
+        stderr: "pipe"
+      }), h = (await new Response(head.stdout).text()).trim();
+      return await head.exited === 0 && SHA_RE.test(h) ? h.toLowerCase() : null;
+    }
+    const proc = Bun.spawn({
+      cmd: ["git", "ls-remote", "https://github.com/stacksjs/stacks.git", `refs/heads/${context.ref}`],
+      stdout: "pipe",
+      stderr: "pipe"
+    }), out = await new Response(proc.stdout).text();
+    if (await proc.exited !== 0)
+      return null;
+    const m = out.match(/^([0-9a-f]{40})\s/i);
+    return m?.[1] ? m[1].toLowerCase() : null;
+  } catch {
+    return null;
+  }
+}
+async function hashFileOrZero(absPath) {
+  try {
+    if (!existsSync(absPath))
+      return 0n;
+    const buf = await Bun.file(absPath).arrayBuffer();
+    return Bun.hash(buf);
+  } catch {
+    return 0n;
+  }
+}
+async function singleFileSnapshot(absPath) {
+  const out = new Map;
+  if (!existsSync(absPath))
+    return out;
+  try {
+    const file = Bun.file(absPath);
+    if (file.size > 0) {
+      const buf = await file.arrayBuffer();
+      out.set("self", { size: file.size, hash: Bun.hash(buf) });
+    }
+  } catch {}
+  return out;
+}
+async function syncFromLocal(stacksRoot, managed, localTarget) {
+  const src = join(stacksRoot, managed.subPath);
+  if (!existsSync(src)) {
+    console.warn(`  skip ${managed.label}: source missing at ${src}`);
+    return;
+  }
+  if (managed.isFile) {
+    mkdirSync(dirname(localTarget), { recursive: !0 });
+    copyFileSync(src, localTarget);
+    return;
+  }
+  mkdirSync(localTarget, { recursive: !0 });
+  cpSync(src, localTarget, {
+    recursive: !0,
+    force: !0,
+    filter: (source) => {
+      if (!managed.skip)
+        return !0;
+      const name = source.split("/").pop() || "";
+      return !managed.skip.includes(name);
+    }
+  });
+}
+async function syncFromGitHub(ref, managed, localTarget, force) {
+  const template = buildTemplateString(ref, managed.subPath);
+  await downloadTemplate(template, {
+    dir: localTarget,
+    force: !0,
+    forceClean: !1,
+    preferOffline: !force
+  });
+}
+async function syncRootFilesFromGitHub(ref) {
+  const tmpDir = p.projectPath(".tmp-upgrade");
+  try {
+    await downloadTemplate(`github:stacksjs/stacks#${ref}`, {
+      dir: tmpDir,
+      force: !0,
+      forceClean: !0,
+      preferOffline: !0,
+      silent: !0
+    });
+    for (const managed of MANAGED_PATHS) {
+      if (!managed.isFile)
+        continue;
+      const src = join(tmpDir, managed.subPath), dest = p.projectPath(managed.localPath);
+      try {
+        if (existsSync(src) && existsSync(dest))
+          copyFileSync(src, dest);
+      } catch {}
+    }
+  } catch {} finally {
+    if (existsSync(tmpDir))
+      rmSync(tmpDir, { recursive: !0, force: !0 });
+  }
+}
+async function runPostSyncHooks(args) {
+  const { aggregate, perPath, projectRoot } = args;
+  if (aggregate.added + aggregate.changed + aggregate.removed === 0) {
+    console.log("Nothing changed \u2014 skipping post-sync hooks.");
+    return;
+  }
+  console.log("Regenerating auto-import manifest...");
+  try {
+    const { generateAutoImportFiles } = await import("@stacksjs/server");
+    await generateAutoImportFiles();
+  } catch (err) {
+    console.warn(`  auto-imports failed (non-fatal): ${err?.message || err}`);
+  }
+  if (perPath.some((entry) => {
+    const { managed, summary } = entry;
+    if (managed.isFile)
+      return !1;
+    if (managed.label !== "core" && managed.label !== "defaults")
+      return !1;
+    if (summary.added + summary.changed === 0)
+      return !1;
+    return pkgJsonInTree(join(projectRoot, managed.localPath));
+  })) {
+    console.log("Running `bun install` to refresh dependencies...");
+    try {
+      const code = await Bun.spawn({
+        cmd: [process.argv[0] || "bun", "install"],
+        cwd: projectRoot,
+        stdout: "inherit",
+        stderr: "inherit"
+      }).exited;
+      if (code !== 0)
+        console.warn(`  bun install exited with code ${code} (non-fatal)`);
+    } catch (err) {
+      console.warn(`  bun install failed (non-fatal): ${err?.message || err}`);
+    }
+  }
+  const migrationsDir = join(projectRoot, "database", "migrations");
+  if (existsSync(migrationsDir)) {
+    console.log("Running pending migrations...");
+    try {
+      const migrateScript = p.frameworkPath("core/buddy/src/cli.ts"), code = await Bun.spawn({
+        cmd: [process.argv[0] || "bun", migrateScript, "migrate"],
+        cwd: projectRoot,
+        stdout: "inherit",
+        stderr: "inherit"
+      }).exited;
+      if (code !== 0)
+        console.warn(`  migrate exited with code ${code} (non-fatal \u2014 DB may not be set up yet)`);
+    } catch (err) {
+      console.warn(`  migrate failed (non-fatal): ${err?.message || err}`);
+    }
+  }
+}
+function pkgJsonInTree(dir) {
+  try {
+    if (!existsSync(dir))
+      return !1;
+    return readFileSync(join(dir, "package.json"), "utf-8").length > 0;
+  } catch {
+    return existsSync(dir);
+  }
+}

package/dist/upgrade/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/upgrade/index.js

@@ -0,0 +1,17 @@
+import process from "node:process";
+import { parseArgs } from "@stacksjs/cli";
+import { Action } from "@stacksjs/enums";
+import { ExitCode } from "@stacksjs/types";
+import { runAction } from "../helpers";
+const options = parseArgs();
+if (options?.framework || options?.all)
+  await runAction(Action.UpgradeFramework, options);
+if (options?.dependencies || options?.all)
+  await runAction(Action.UpgradeDeps, options);
+if (options?.bun || options?.all)
+  await runAction(Action.UpgradeBun, options);
+if (options?.shell || options?.all)
+  await runAction(Action.UpgradeShell, options);
+if (options?.binary || options?.all)
+  await runAction(Action.UpgradeBinary, options);
+process.exit(ExitCode.Success);

package/dist/upgrade/packages.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Upgrade a node_modules app to a published framework version. Called by the
+ * framework upgrade script when no vendored `storage/framework/core` exists.
+ * Handles resolution, package.json rewrite, and reinstall; then `process.exit`s.
+ */
+export declare function upgradeStacksPackages(projectRoot: string, options: PackageUpgradeOptions): Promise<never>;
+export declare interface PackageUpgradeOptions {
+  version?: string
+  canary?: boolean
+  stable?: boolean
+  force?: boolean
+  dryRun?: boolean
+  noPostinstall?: boolean
+}

package/dist/upgrade/packages.js

@@ -0,0 +1,99 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import process from "node:process";
+import { runCommand } from "@stacksjs/cli";
+async function resolveTarget(options) {
+  const res = await fetch("https://registry.npmjs.org/stacks").catch(() => null);
+  if (!res || !res.ok)
+    throw Error("Could not reach the npm registry to resolve the target `stacks` version.");
+  const meta = await res.json(), distTags = meta["dist-tags"] ?? {}, versions = meta.versions ?? {};
+  let version;
+  if (options.version) {
+    if (!versions[options.version])
+      throw Error(`stacks@${options.version} was not found on the npm registry.`);
+    version = options.version;
+  } else {
+    const tag = options.canary ? "canary" : "latest", resolved = distTags[tag];
+    if (!resolved)
+      throw Error(`The \`${tag}\` dist-tag is not published for \`stacks\`.`);
+    version = resolved;
+  }
+  const coreDeps = new Set(Object.keys(versions[version]?.dependencies ?? {}));
+  return { version, coreDeps };
+}
+function applyBumps(pkg, target, coreDeps) {
+  const changes = [], isLockstep = (name) => name === "stacks" || name.startsWith("@stacksjs/") && coreDeps.has(name);
+  for (const field of ["dependencies", "devDependencies"]) {
+    const deps = pkg[field];
+    if (!deps)
+      continue;
+    for (const [name, spec] of Object.entries(deps)) {
+      if (!isLockstep(name))
+        continue;
+      const next = `${/^[\^~]/.test(spec) ? spec[0] : /^\d/.test(spec) ? "" : "^"}${target}`;
+      if (spec !== next) {
+        changes.push({ name, from: spec, to: next });
+        deps[name] = next;
+      }
+    }
+  }
+  return changes;
+}
+export async function upgradeStacksPackages(projectRoot, options) {
+  const pkgPath = join(projectRoot, "package.json");
+  if (!existsSync(pkgPath)) {
+    console.error("No package.json found \u2014 nothing to upgrade.");
+    process.exit(1);
+  }
+  const raw = readFileSync(pkgPath, "utf-8"), pkg = JSON.parse(raw), current = pkg.dependencies?.stacks ?? pkg.devDependencies?.stacks, { version: target, coreDeps } = await resolveTarget(options).catch((err) => {
+    console.error(`\u2717 ${err.message}`);
+    process.exit(1);
+  });
+  console.log(`
+  Upgrading the Stacks framework${options.canary ? " (canary)" : ""} \u2192 ${target}`);
+  if (current)
+    console.log(`  current \`stacks\` constraint: ${current}
+`);
+  const changes = applyBumps(pkg, target, coreDeps);
+  if (changes.length === 0 && !options.force) {
+    console.log(`\u2714 Already up to date \u2014 every framework dependency matches the target.
+`);
+    process.exit(0);
+  }
+  if (changes.length > 0) {
+    console.log("  The following dependencies will be updated:");
+    const width = Math.max(...changes.map((c) => c.name.length));
+    for (const c of changes)
+      console.log(`    ${c.name.padEnd(width)}  ${c.from}  \u2192  ${c.to}`);
+    console.log("");
+  }
+  if (options.dryRun) {
+    console.log(`  --dry-run: no files were written and nothing was installed.
+`);
+    process.exit(0);
+  }
+  if (changes.length > 0) {
+    const trailing = raw.endsWith(`
+`) ? `
+` : "";
+    writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}${trailing}`);
+    console.log("\u2714 Updated package.json");
+  }
+  const frameworkPkgs = ["stacks", ...[...coreDeps].filter((n) => n.startsWith("@stacksjs/"))];
+  if (options.noPostinstall) {
+    console.log("  --no-postinstall: skipping install. Run this to pull the new versions:");
+    console.log(`    bun update ${frameworkPkgs.slice(0, 3).join(" ")} \u2026
+`);
+    process.exit(0);
+  }
+  console.log(`  Installing\u2026
+`);
+  if ((await runCommand(`bun update ${frameworkPkgs.join(" ")}`, { cwd: projectRoot })).isErr) {
+    console.error("\n\u2717 The install step failed. Your package.json was updated \u2014 resolve the error and re-run `bun update`.\n");
+    process.exit(1);
+  }
+  console.log(`
+\u2714 Upgraded to stacks@${target}. Review the changelog: https://github.com/stacksjs/stacks/releases/tag/v${target}
+`);
+  process.exit(0);
+}

package/dist/upgrade/shell.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/upgrade/shell.js

@@ -0,0 +1,41 @@
+import { $ } from "bun";
+import process from "node:process";
+import { italic, runCommand } from "@stacksjs/cli";
+import { log } from "@stacksjs/logging";
+import { path as p } from "@stacksjs/path";
+import { writeFile } from "@stacksjs/storage";
+import { ExitCode } from "@stacksjs/types";
+const homePath = (await $`echo $HOME`.text()).trim(), zshrcPath = p.join(homePath, ".zshrc"), pluginPath = p.shellPath("src/buddy.plugin.zsh"), customPath = p.join(homePath, ".oh-my-zsh/custom/plugins/buddy/");
+log.info(`Setting up Oh My Zsh via ${zshrcPath}...`);
+$.cwd(p.dirname(zshrcPath));
+let data = await $`cat ${p.basename(zshrcPath)}`.text();
+const pluginLineRegex = /^(?!#).*plugins=\(([^)]+)\)/m, match = data.match(pluginLineRegex);
+if (match) {
+  const plugins = match[1]?.split(/\s+/).filter(Boolean);
+  if (!plugins) {
+    log.error("Maybe the plugins line in your .zshrc file could not be found? If this continues being an issue, please reach out to us on Discord.");
+    process.exit(ExitCode.FatalError);
+  }
+  if (!plugins.includes("buddy")) {
+    plugins.push("buddy");
+    const newPluginLine = `plugins=(
+    ${plugins.map((plugin) => plugin.trim()).join(`
+    `)}
+)`;
+    data = data.replace(pluginLineRegex, newPluginLine);
+    await writeFile(zshrcPath, data);
+    log.info(`Copying buddy zsh plugin ${pluginPath} to ${customPath}...`);
+    await runCommand(`mkdir -p ${customPath}`);
+    await runCommand(`cp -rf ${pluginPath} ${customPath}`);
+    log.success("Copied buddy zsh plugin");
+  } else {
+    log.info("Buddy is already set up");
+    log.info("Ensuring `buddy` is updated...");
+    await runCommand(`cp -rf ${pluginPath} ${customPath}`);
+    log.success("Updated buddy zsh plugin to latest version");
+  }
+}
+log.success("Oh My Zsh Setup Complete");
+log.info(italic("To see changes reflect, you may need to open a new terminal window"));
+if (process.env.TERM_PROGRAM === "vscode")
+  log.info("\u2318\u21E7P terminal.create.new.terminal");