@sfmc-bds/cli 0.1.0 → 0.2.0-beta.0

package/dist/pack-lifecycle.js

@@ -0,0 +1,634 @@
+import {
+  configPath,
+  modulePath,
+  readJson,
+  writeJson
+} from "@sfmc-bds/sdk/node/config";
+import { existsSync, readFileSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pushLog } from "./logs.js";
+import { dirFingerprint } from "./module-fingerprint.js";
+import { failResult, okResult } from "./cli-result.js";
+import { t } from "./i18n/index.js";
+import {
+  assembleBehaviorPack,
+  assembleResourcePack,
+  bdsWorldLevelDir,
+  bdsWorldsDir,
+  configPermissionPath,
+  deployToBDS,
+  disablePackInWorld,
+  enablePackInWorld,
+  ensureConfigPermission,
+  hasConfigPermission,
+  readLevelNameSync,
+  readPackManifestHeader,
+  readWorldPackList,
+  worldPackListHas as pmWorldPackListHas
+} from "@sfmc-bds/bds-tools/pack-manager-lib";
+import { ROOT, PACKAGES_DIR, resolveSdkPackageRoot } from "./runtime.js";
+import { c } from "./theme.js";
+const BP_NAME = "sfmc-modules";
+const RP_NAME = "sfmc-modules-rp";
+const DEPLOY_CATALOG_NAME = "sfmc-deploy-catalog.json";
+const DEFAULT_PACK_VERSION = [1, 0, 0];
+function createSdkResolvePlugin(sdkRoot) {
+  const pkg = JSON.parse(readFileSync(path.join(sdkRoot, "package.json"), "utf8"));
+  const exportsMap = pkg.exports ?? {};
+  function resolveExportSubpath(subpath) {
+    const key = subpath === "" ? "." : `./${subpath}`;
+    const entry = exportsMap[key];
+    if (!entry) return null;
+    const rel = typeof entry === "string" ? entry : entry.import ?? entry.default;
+    if (!rel || typeof rel !== "string") return null;
+    const abs = path.join(sdkRoot, rel);
+    return existsSync(abs) ? abs : null;
+  }
+  return {
+    name: "sfmc-sdk-resolve",
+    setup(build) {
+      build.onResolve({ filter: /^@sfmc(?:-bds)?\/sdk(?:\/|$)/ }, (args) => {
+        const normalized = args.path.replace(/^@sfmc\/sdk/, "@sfmc-bds/sdk");
+        const sub = normalized === "@sfmc-bds/sdk" ? "" : normalized.slice("@sfmc-bds/sdk/".length);
+        const resolved = resolveExportSubpath(sub);
+        if (!resolved) {
+          return {
+            errors: [
+              {
+                text: `Cannot resolve ${args.path} under SDK at ${sdkRoot} (export "./${sub || "."}" missing or file absent; run sdk:build?)`
+              }
+            ]
+          };
+        }
+        return { path: resolved };
+      });
+    }
+  };
+}
+function buildRoot() {
+  return path.join(ROOT, "packs", "_build");
+}
+function bpSrc() {
+  return path.join(buildRoot(), `${BP_NAME}-bp`);
+}
+function bpOut() {
+  return path.join(buildRoot(), BP_NAME);
+}
+function rpOut() {
+  return path.join(buildRoot(), RP_NAME);
+}
+function packLog(text, level = "info") {
+  pushLog(text, "pack", level);
+}
+function packagesDir() {
+  return PACKAGES_DIR || path.join(ROOT, "modules", "packages");
+}
+function lockPath() {
+  return modulePath(path.join(ROOT, "modules"), "module-lock.json");
+}
+function catalogPath() {
+  return modulePath(path.join(ROOT, "modules"), "catalog.json");
+}
+function resolveBdsContext() {
+  const cfg = readJson(configPath(ROOT, "bds_updater.json")) ?? {};
+  const bdsRoot = cfg.bds_path;
+  if (!bdsRoot) {
+    throw new Error("bds_path not configured. Run `sfmc init` first.");
+  }
+  return { bdsRoot, levelName: readLevelNameSync(bdsRoot) };
+}
+function deployedBpDir(bdsRoot, levelName) {
+  return path.join(bdsWorldLevelDir(bdsRoot, levelName), "behavior_packs", BP_NAME);
+}
+function deployedRpDir(bdsRoot, levelName) {
+  return path.join(bdsWorldLevelDir(bdsRoot, levelName), "resource_packs", RP_NAME);
+}
+function deployedCatalogPath(bdsRoot, levelName) {
+  return path.join(deployedBpDir(bdsRoot, levelName), DEPLOY_CATALOG_NAME);
+}
+function isModuleEnabled(logicalId, lock, catalogDefaults) {
+  const st = lock.modules?.[logicalId];
+  if (st && typeof st.enabled === "boolean") return st.enabled;
+  return catalogDefaults.get(logicalId) ?? false;
+}
+function collectDeployedPackUuids(bdsRoot, levelName) {
+  const bp = /* @__PURE__ */ new Set();
+  const rp = /* @__PURE__ */ new Set();
+  const cat = readDeployedCatalog(bdsRoot, levelName);
+  if (cat?.bpUuid) bp.add(cat.bpUuid);
+  if (cat?.rpUuid) rp.add(cat.rpUuid);
+  const liveBp = readPackManifestHeader(deployedBpDir(bdsRoot, levelName));
+  const liveRp = readPackManifestHeader(deployedRpDir(bdsRoot, levelName));
+  if (liveBp?.uuid) bp.add(liveBp.uuid);
+  if (liveRp?.uuid) rp.add(liveRp.uuid);
+  return { bp, rp };
+}
+async function scanLocalModules() {
+  const dir = packagesDir();
+  if (!existsSync(dir)) return [];
+  const lock = readJson(lockPath()) ?? { version: 1, modules: {} };
+  const cat = readJson(catalogPath()) ?? {};
+  const defaults = /* @__PURE__ */ new Map();
+  if (Array.isArray(cat.modules)) {
+    for (const m of cat.modules) {
+      const id = typeof m.id === "string" ? m.id : "";
+      if (!id) continue;
+      defaults.set(id, m.enabledByDefault !== false);
+    }
+  }
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  const out = [];
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    const folderId = e.name;
+    const modPath = path.join(dir, folderId);
+    const manifestPath = path.join(modPath, "sapi", "manifest.json");
+    const entryPath = path.join(modPath, "sapi", "src", "index.ts");
+    let logicalId = folderId;
+    let version = "0.0.0";
+    if (existsSync(manifestPath)) {
+      try {
+        const man = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+        if (typeof man.id === "string" && man.id) logicalId = man.id;
+        if (typeof man.version === "string" && man.version) version = man.version;
+        else if (typeof man.schemaVersion === "number") version = `schema-${man.schemaVersion}`;
+      } catch {
+      }
+    }
+    const hasSapi = existsSync(entryPath);
+    const hasResourcePack = existsSync(path.join(modPath, "resource_pack"));
+    const fingerprint = await dirFingerprint(modPath);
+    const enabled = isModuleEnabled(logicalId, lock, defaults);
+    out.push({
+      folderId,
+      logicalId,
+      version,
+      enabled,
+      hasSapi,
+      hasResourcePack,
+      fingerprint,
+      entryPath: hasSapi ? entryPath : null
+    });
+  }
+  out.sort((a, b) => a.folderId.localeCompare(b.folderId));
+  return out;
+}
+async function computeDesiredCatalog(opts) {
+  const mods = await scanLocalModules();
+  const modules = {};
+  let anyRp = false;
+  for (const m of mods) {
+    modules[m.folderId] = {
+      logicalId: m.logicalId,
+      enabled: m.enabled,
+      version: m.version,
+      fingerprint: m.fingerprint,
+      hasResourcePack: m.hasResourcePack
+    };
+    if (m.enabled && m.hasResourcePack) anyRp = true;
+  }
+  const localBp = readPackManifestHeader(bpOut());
+  const localRp = readPackManifestHeader(rpOut());
+  const bpUuid = opts?.bpUuid ?? localBp?.uuid ?? crypto.randomUUID();
+  const bpVersion = opts?.bpVersion ?? localBp?.version ?? DEFAULT_PACK_VERSION;
+  const bpModuleUuid = opts?.bpModuleUuid ?? localBp?.moduleUuid;
+  let rpUuid = null;
+  let rpVersion = null;
+  let rpModuleUuid;
+  if (anyRp) {
+    rpUuid = opts?.rpUuid ?? localRp?.uuid ?? crypto.randomUUID();
+    rpVersion = opts?.rpVersion ?? localRp?.version ?? DEFAULT_PACK_VERSION;
+    rpModuleUuid = opts?.rpModuleUuid ?? localRp?.moduleUuid;
+  }
+  return {
+    schemaVersion: 1,
+    bpUuid,
+    rpUuid,
+    bpVersion,
+    rpVersion,
+    ...bpModuleUuid ? { bpModuleUuid } : {},
+    ...rpModuleUuid ? { rpModuleUuid } : {},
+    generatedAt: Date.now(),
+    modules
+  };
+}
+function readDeployedCatalog(bdsRoot, levelName) {
+  const file = deployedCatalogPath(bdsRoot, levelName);
+  if (!existsSync(file)) return null;
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function catalogsEqual(a, b) {
+  if (a.bpUuid !== b.bpUuid) return false;
+  if ((a.rpUuid ?? null) !== (b.rpUuid ?? null)) return false;
+  const aKeys = Object.keys(a.modules).sort();
+  const bKeys = Object.keys(b.modules).sort();
+  if (aKeys.length !== bKeys.length) return false;
+  for (let i = 0; i < aKeys.length; i++) {
+    if (aKeys[i] !== bKeys[i]) return false;
+  }
+  for (const k of aKeys) {
+    const x = a.modules[k];
+    const y = b.modules[k];
+    if (x.logicalId !== y.logicalId || x.enabled !== y.enabled || x.version !== y.version || x.fingerprint !== y.fingerprint || x.hasResourcePack !== y.hasResourcePack) {
+      return false;
+    }
+  }
+  return true;
+}
+function worldPackListHas(bdsRoot, levelName, kind, uuid) {
+  return pmWorldPackListHas(bdsWorldsDir(bdsRoot), levelName, kind, uuid);
+}
+async function buildPacks(desired) {
+  await fs.mkdir(buildRoot(), { recursive: true });
+  const catalog = desired ?? await computeDesiredCatalog();
+  packLog(`building BP/RP (modules=${Object.keys(catalog.modules).length})\u2026`);
+  const mods = await scanLocalModules();
+  const entries = mods.filter((m) => m.enabled && m.entryPath).map((m) => m.entryPath);
+  const rpDirs = {};
+  for (const m of mods) {
+    if (!m.enabled || !m.hasResourcePack) continue;
+    rpDirs[m.folderId] = path.join(packagesDir(), m.folderId, "resource_pack");
+  }
+  const { build } = await import("esbuild");
+  const outFile = path.join(bpSrc(), "scripts", "main.js");
+  await fs.mkdir(path.dirname(outFile), { recursive: true });
+  if (entries.length === 0) {
+    await fs.writeFile(outFile, "/* no modules enabled */\n", "utf8");
+    packLog("no enabled SAPI modules \u2014 empty main.js", "warn");
+  } else {
+    const sdkRoot = resolveSdkPackageRoot();
+    packLog(`SDK root: ${sdkRoot}`);
+    await build({
+      entryPoints: entries,
+      outfile: outFile,
+      bundle: true,
+      platform: "neutral",
+      format: "esm",
+      target: "es2022",
+      logLevel: "warning",
+      sourcemap: false,
+      external: ["@minecraft/*"],
+      // 避免读取模块内残缺的 extends（如 ../../../sdk/@sfmc-sdk/tsconfig.json）
+      tsconfigRaw: JSON.stringify({
+        compilerOptions: {
+          module: "ESNext",
+          moduleResolution: "bundler",
+          target: "ES2022",
+          strict: true,
+          skipLibCheck: true
+        }
+      }),
+      plugins: [createSdkResolvePlugin(sdkRoot)]
+    });
+    packLog(`esbuild bundled ${entries.length} entr(y/ies)`, "success");
+  }
+  try {
+    await assembleBehaviorPack({
+      srcDir: bpSrc(),
+      outDir: bpOut(),
+      projectName: BP_NAME,
+      version: catalog.bpVersion,
+      description: "ScriptsForMinecraftServer aggregated behavior pack",
+      uuid: catalog.bpUuid,
+      ...catalog.bpModuleUuid ? { moduleUuid: catalog.bpModuleUuid } : {}
+    });
+  } catch (e) {
+    throw new Error(`assemble-bp failed: ${e.message}`);
+  }
+  packLog(`assembled BP uuid=${catalog.bpUuid}`, "success");
+  if (Object.keys(rpDirs).length > 0 && catalog.rpUuid) {
+    try {
+      await assembleResourcePack({
+        moduleResourceDirs: rpDirs,
+        outDir: rpOut(),
+        projectName: RP_NAME,
+        version: catalog.rpVersion ?? DEFAULT_PACK_VERSION,
+        description: "ScriptsForMinecraftServer aggregated resource pack",
+        uuid: catalog.rpUuid,
+        ...catalog.rpModuleUuid ? { moduleUuid: catalog.rpModuleUuid } : {}
+      });
+    } catch (e) {
+      throw new Error(`assemble-rp failed: ${e.message}`);
+    }
+    packLog(`assembled RP uuid=${catalog.rpUuid} (${Object.keys(rpDirs).length} modules)`, "success");
+  } else {
+    await fs.rm(rpOut(), { recursive: true, force: true });
+    catalog.rpUuid = null;
+    catalog.rpVersion = null;
+    packLog("no enabled resource packs \u2014 RP skipped");
+  }
+  catalog.generatedAt = Date.now();
+  writeJson(path.join(bpOut(), DEPLOY_CATALOG_NAME), catalog);
+  return catalog;
+}
+async function deployPacks(catalog) {
+  const { bdsRoot, levelName } = resolveBdsContext();
+  if (!existsSync(bpOut())) {
+    throw new Error(`BP not built at ${bpOut()}. Run build first.`);
+  }
+  const previous = collectDeployedPackUuids(bdsRoot, levelName);
+  try {
+    await deployToBDS({
+      bdsRoot,
+      levelName,
+      behaviorPackSrc: bpOut(),
+      bpName: BP_NAME,
+      rpName: RP_NAME,
+      ...catalog.rpUuid && existsSync(rpOut()) ? { resourcePackSrc: rpOut() } : { clearResourcePack: true }
+    });
+  } catch (e) {
+    throw new Error(`deploy failed: ${e.message}`);
+  }
+  packLog(`deployed to worlds/${levelName}`, "success");
+  writeJson(path.join(deployedBpDir(bdsRoot, levelName), DEPLOY_CATALOG_NAME), catalog);
+  const worldsDir = bdsWorldsDir(bdsRoot);
+  try {
+    await enablePackInWorld({
+      worldsDir,
+      levelName,
+      kind: "behavior",
+      packUuid: catalog.bpUuid,
+      version: catalog.bpVersion
+    });
+  } catch (e) {
+    throw new Error(`enable BP failed: ${e.message}`);
+  }
+  packLog(`enabled behavior pack ${catalog.bpUuid} in world list`, "success");
+  if (catalog.rpUuid && catalog.rpVersion) {
+    try {
+      await enablePackInWorld({
+        worldsDir,
+        levelName,
+        kind: "resource",
+        packUuid: catalog.rpUuid,
+        version: catalog.rpVersion
+      });
+    } catch (e) {
+      throw new Error(`enable RP failed: ${e.message}`);
+    }
+    packLog(`enabled resource pack ${catalog.rpUuid} in world list`, "success");
+  }
+  for (const staleRp of previous.rp) {
+    if (staleRp === (catalog.rpUuid ?? null)) continue;
+    try {
+      await disablePackInWorld({
+        worldsDir,
+        levelName,
+        kind: "resource",
+        packUuid: staleRp,
+        version: DEFAULT_PACK_VERSION
+      });
+      packLog(`disabled stale resource pack ${staleRp}`, "success");
+    } catch (e) {
+      packLog(`disable stale RP ${staleRp} failed: ${e.message}`, "warn");
+    }
+  }
+  for (const staleBp of previous.bp) {
+    if (staleBp === catalog.bpUuid) continue;
+    try {
+      await disablePackInWorld({
+        worldsDir,
+        levelName,
+        kind: "behavior",
+        packUuid: staleBp,
+        version: DEFAULT_PACK_VERSION
+      });
+      packLog(`disabled stale behavior pack ${staleBp}`, "success");
+    } catch (e) {
+      packLog(`disable stale BP ${staleBp} failed: ${e.message}`, "warn");
+    }
+  }
+  try {
+    const wrote = await ensureConfigPermission(bdsRoot, catalog.bpUuid);
+    const permRel = path.relative(bdsRoot, configPermissionPath(bdsRoot, catalog.bpUuid));
+    packLog(wrote ? `wrote ${permRel}` : `${permRel} already exists \u2014 skipped`);
+  } catch (e) {
+    throw new Error(`ensure-permission failed: ${e.message}`);
+  }
+}
+function formatPackLoadInfo(catalog, rebuilt) {
+  const mods = Object.entries(catalog.modules);
+  const enabled = mods.filter(([, m]) => m.enabled);
+  const disabled = mods.filter(([, m]) => !m.enabled);
+  const lines = [
+    `pack load ${rebuilt ? "(rebuilt)" : "(catalog match \u2014 skip rebuild)"}`,
+    `  BP ${catalog.bpUuid}  v${catalog.bpVersion.join(".")}`,
+    catalog.rpUuid ? `  RP ${catalog.rpUuid}  v${(catalog.rpVersion ?? DEFAULT_PACK_VERSION).join(".")}` : `  RP (none)`,
+    `  modules: ${enabled.length} enabled / ${disabled.length} disabled / ${mods.length} installed`
+  ];
+  for (const [folderId, m] of enabled.sort((a, b) => a[0].localeCompare(b[0]))) {
+    lines.push(`    \u25CF ${folderId} (${m.logicalId}) ${m.version}${m.hasResourcePack ? " +rp" : ""}`);
+  }
+  for (const [folderId, m] of disabled.sort((a, b) => a[0].localeCompare(b[0]))) {
+    lines.push(`    \u25CB ${folderId} (${m.logicalId}) disabled`);
+  }
+  return lines.join("\n");
+}
+function reusePackIds(deployed) {
+  return {
+    bpUuid: deployed.bpUuid,
+    rpUuid: deployed.rpUuid,
+    bpVersion: deployed.bpVersion,
+    rpVersion: deployed.rpVersion,
+    ...deployed.bpModuleUuid ? { bpModuleUuid: deployed.bpModuleUuid } : {},
+    ...deployed.rpModuleUuid ? { rpModuleUuid: deployed.rpModuleUuid } : {}
+  };
+}
+async function ensurePacksReady() {
+  const { bdsRoot, levelName } = resolveBdsContext();
+  packLog(`preflight: checking packs for ${bdsRoot} / ${levelName}`);
+  const deployed = readDeployedCatalog(bdsRoot, levelName);
+  let desired = await computeDesiredCatalog(deployed ? reusePackIds(deployed) : void 0);
+  const needsRp = Object.values(desired.modules).some((m) => m.enabled && m.hasResourcePack);
+  if (needsRp && !desired.rpUuid) {
+    desired = await computeDesiredCatalog({
+      bpUuid: desired.bpUuid,
+      bpVersion: desired.bpVersion,
+      ...desired.bpModuleUuid ? { bpModuleUuid: desired.bpModuleUuid } : {},
+      rpUuid: crypto.randomUUID(),
+      rpVersion: DEFAULT_PACK_VERSION
+    });
+  }
+  if (!needsRp) {
+    desired.rpUuid = null;
+    desired.rpVersion = null;
+  }
+  let needRebuild = !deployed || !catalogsEqual(desired, deployed);
+  if (!needRebuild && deployed) {
+    if (!worldPackListHas(bdsRoot, levelName, "behavior", deployed.bpUuid)) needRebuild = true;
+    if (deployed.rpUuid && !worldPackListHas(bdsRoot, levelName, "resource", deployed.rpUuid)) {
+      needRebuild = true;
+    }
+    if (!hasConfigPermission(bdsRoot, deployed.bpUuid)) {
+      try {
+        const wrote = await ensureConfigPermission(bdsRoot, deployed.bpUuid);
+        const permRel = path.relative(bdsRoot, configPermissionPath(bdsRoot, deployed.bpUuid));
+        packLog(wrote ? `wrote ${permRel}` : `${permRel} already exists \u2014 skipped`);
+      } catch (e) {
+        throw new Error(`ensure-permission failed: ${e.message}`);
+      }
+    }
+  }
+  let rebuilt = false;
+  if (needRebuild) {
+    packLog("catalog mismatch \u2014 rebuilding packs\u2026", "warn");
+    desired = await buildPacks(desired);
+    await deployPacks(desired);
+    rebuilt = true;
+  } else {
+    packLog("catalog match \u2014 skip rebuild", "success");
+  }
+  const summary = formatPackLoadInfo(desired, rebuilt);
+  for (const line of summary.split("\n")) packLog(line, rebuilt ? "success" : "info");
+  return {
+    rebuilt,
+    skipped: !rebuilt,
+    catalog: desired,
+    bdsRoot,
+    levelName,
+    summary
+  };
+}
+async function cmdPackBuild(_args) {
+  try {
+    const cat = await buildPacks();
+    return okResult(c.green(t("pack.built", { path: bpOut() })) + `
+` + formatPackLoadInfo(cat, true) + "\n");
+  } catch (e) {
+    packLog(e.message, "error");
+    return failResult(c.red(t("pack.buildFailed", { message: e.message })));
+  }
+}
+async function cmdPackDeploy(_args) {
+  try {
+    const localCatFile = path.join(bpOut(), DEPLOY_CATALOG_NAME);
+    let cat;
+    if (existsSync(localCatFile)) {
+      cat = JSON.parse(await fs.readFile(localCatFile, "utf8"));
+    } else {
+      cat = await buildPacks();
+    }
+    await deployPacks(cat);
+    return okResult(c.green(t("pack.deployed")) + "\n" + formatPackLoadInfo(cat, true) + "\n");
+  } catch (e) {
+    packLog(e.message, "error");
+    return failResult(c.red(t("pack.deployFailed", { message: e.message })));
+  }
+}
+async function cmdPackStatus(_args) {
+  try {
+    const { bdsRoot, levelName } = resolveBdsContext();
+    const deployed = readDeployedCatalog(bdsRoot, levelName);
+    const desired = await computeDesiredCatalog(deployed ? reusePackIds(deployed) : void 0);
+    const match = deployed ? catalogsEqual(desired, deployed) : false;
+    const permPath = deployed ? configPermissionPath(bdsRoot, deployed.bpUuid) : null;
+    const lines = [
+      c.bold("\nPack status"),
+      `  bds        : ${bdsRoot}`,
+      `  level      : ${levelName}`,
+      `  catalog    : ${match ? c.green("in sync") : c.yellow(deployed ? "mismatch \u2014 will rebuild on start" : "missing")}`,
+      `  BP dir     : ${deployedBpDir(bdsRoot, levelName)} ${existsSync(deployedBpDir(bdsRoot, levelName)) ? c.green("\u2713") : c.red("\u2717")}`,
+      `  RP dir     : ${deployedRpDir(bdsRoot, levelName)} ${existsSync(deployedRpDir(bdsRoot, levelName)) ? c.green("\u2713") : c.dim("\u2014")}`,
+      `  permission : ${permPath ? existsSync(permPath) ? c.green(permPath) : c.yellow("missing") : c.dim("n/a")}`
+    ];
+    if (deployed) {
+      lines.push(`  BP uuid    : ${deployed.bpUuid}`);
+      if (deployed.rpUuid) lines.push(`  RP uuid    : ${deployed.rpUuid}`);
+      lines.push(
+        `  world BP   : ${worldPackListHas(bdsRoot, levelName, "behavior", deployed.bpUuid) ? c.green("listed") : c.red("not listed")}`
+      );
+      if (deployed.rpUuid) {
+        lines.push(
+          `  world RP   : ${worldPackListHas(bdsRoot, levelName, "resource", deployed.rpUuid) ? c.green("listed") : c.red("not listed")}`
+        );
+      }
+    }
+    lines.push(formatPackLoadInfo(desired, false));
+    return lines.join("\n") + "\n";
+  } catch (e) {
+    return c.red(t("pack.statusFailed", { message: e.message }));
+  }
+}
+async function cmdPackList(_args) {
+  try {
+    const { bdsRoot, levelName } = resolveBdsContext();
+    const mods = await scanLocalModules();
+    const lines = [c.bold("\nModules / resource packs"), c.dim(`  ${packagesDir()}`)];
+    for (const m of mods) {
+      const mark = m.enabled ? c.green("\u25CF") : c.dim("\u25CB");
+      lines.push(
+        `  ${mark} ${m.folderId.padEnd(24)} ${m.logicalId.padEnd(24)} ${m.enabled ? "on " : "off"} ${m.hasResourcePack ? "+rp" : "   "} ${m.version}`
+      );
+    }
+    const worldsDir = bdsWorldsDir(bdsRoot);
+    lines.push(c.bold("\nWorld enable lists"));
+    for (const kind of ["behavior", "resource"]) {
+      const arr = readWorldPackList(worldsDir, levelName, kind);
+      if (!arr.length) lines.push(c.dim(`  ${kind}: (empty)`));
+      for (const e of arr) {
+        lines.push(`  ${kind}: ${e.pack_id}  v${(e.version ?? []).join(".")}`);
+      }
+    }
+    return lines.join("\n") + "\n";
+  } catch (e) {
+    return c.red(t("pack.listFailed", { message: e.message }));
+  }
+}
+async function cmdPackEnableDisable(action, args) {
+  try {
+    const kind = args[0] === "resource" || args[0] === "rp" ? "resource" : "behavior";
+    const { bdsRoot, levelName } = resolveBdsContext();
+    const deployed = readDeployedCatalog(bdsRoot, levelName);
+    if (!deployed) return c.red(t("pack.noCatalog"));
+    const uuid = kind === "behavior" ? deployed.bpUuid : deployed.rpUuid;
+    const version = kind === "behavior" ? deployed.bpVersion : deployed.rpVersion;
+    if (!uuid || !version) return c.red(t("pack.noUuid", { kind }));
+    const worldsDir = bdsWorldsDir(bdsRoot);
+    try {
+      const opts = { worldsDir, levelName, kind, packUuid: uuid, version };
+      if (action === "enable") await enablePackInWorld(opts);
+      else await disablePackInWorld(opts);
+    } catch (e) {
+      return c.red(t("pack.actionFailed", { action, detail: e.message }));
+    }
+    packLog(`${action}d ${kind} pack ${uuid}`, "success");
+    return c.green(
+      action === "enable" ? t("pack.enabledOk", { kind, uuid }) : t("pack.disabledOk", { kind, uuid })
+    );
+  } catch (e) {
+    return c.red(t("pack.actionErr", { action, message: e.message }));
+  }
+}
+export {
+  BP_NAME,
+  DEFAULT_PACK_VERSION,
+  DEPLOY_CATALOG_NAME,
+  RP_NAME,
+  bpOut,
+  bpSrc,
+  buildPacks,
+  buildRoot,
+  catalogsEqual,
+  cmdPackBuild,
+  cmdPackDeploy,
+  cmdPackEnableDisable,
+  cmdPackList,
+  cmdPackStatus,
+  computeDesiredCatalog,
+  deployPacks,
+  deployedBpDir,
+  deployedCatalogPath,
+  deployedRpDir,
+  ensurePacksReady,
+  formatPackLoadInfo,
+  readDeployedCatalog,
+  resolveBdsContext,
+  rpOut,
+  scanLocalModules
+};
+//# sourceMappingURL=pack-lifecycle.js.map