@tapestry-mud/cli 0.7.0 → 0.8.0

package/bin/tapestry.js

@@ -30,6 +30,7 @@ const { unpublish } = require('../src/commands/unpublish');
 const { distTagSet, distTagList } = require('../src/commands/dist-tag');
 const { presetSet, presetDelete } = require('../src/commands/preset');
 const { trustAdd, trustList, trustRm } = require('../src/commands/trust');
+const { syncArea } = require('../src/commands/sync-area');
 
 const program = new Command();
 
@@ -59,7 +60,7 @@ program.configureHelp({
       },
       {
         title: 'Pack Authoring',
-        commands: ['create', 'validate', 'pack', 'publish', 'unpublish'],
+        commands: ['create', 'validate', 'pack', 'publish', 'unpublish', 'sync-area'],
       },
       {
         title: 'Trusted Publishing',
@@ -360,6 +361,47 @@ program
     }
   });
 
+function runSyncArea(areaRef, opts) {
+  try {
+    syncArea(areaRef, {
+      cwd: process.cwd(),
+      gameRoot: opts.gameRoot,
+      pack: opts.pack,
+      force: opts.force,
+      keepSidecars: opts.keepSidecars,
+      bump: opts.major ? 'major' : opts.minor ? 'minor' : 'patch',
+    });
+  } catch (e) {
+    console.error(`error: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+program
+  .command('sync-area <areaRef>')
+  .description('Commit a game-root authored area back into its pack (areaRef = namespace:area-id)')
+  .option('--pack <dir>', 'Target pack directory (auto-detected from linked packs by default)')
+  .option('--game-root <path>', 'Game root containing data/ (default: current dir)')
+  .option('--keep-sidecars', 'Copy instead of move (leave the game-root side-cars in place)')
+  .option('--force', 'Overwrite pack files that diverge from the side-car')
+  .option('--minor', 'Bump the pack minor version (default: patch)')
+  .option('--major', 'Bump the pack major version (default: patch)')
+  .action(runSyncArea);
+
+program
+  .command('export-area <areaRef>', { hidden: true })
+  .description('(deprecated) alias for sync-area')
+  .option('--pack <dir>', 'Target pack directory (auto-detected from linked packs by default)')
+  .option('--game-root <path>', 'Game root containing data/ (default: current dir)')
+  .option('--keep-sidecars', 'Copy instead of move (leave the game-root side-cars in place)')
+  .option('--force', 'Overwrite pack files that diverge from the side-car')
+  .option('--minor', 'Bump the pack minor version (default: patch)')
+  .option('--major', 'Bump the pack major version (default: patch)')
+  .action((areaRef, opts) => {
+    console.warn('warning: `export-area` is deprecated; use `sync-area`.');
+    runSyncArea(areaRef, opts);
+  });
+
 program
   .command('search <query>')
   .description('Search the registry by keyword')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tapestry-mud/cli",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "CLI for the Tapestry MUD engine",
   "repository": {
     "type": "git",

package/src/commands/sync-area.js

@@ -0,0 +1,156 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { readYaml, writeYaml } = require('../util/yaml');
+const { readLinks } = require('../lib/links');
+const { ensureContentGlobs, bumpVersion } = require('../lib/pack-manifest');
+const { isRepo, commitAll } = require('../lib/git');
+
+// "@legends/forgotten" -> "legends-forgotten" (mirrors engine PackLoader.PackNamespace)
+function packNamespace(name) {
+  if (name.indexOf('/') === -1) {
+    return name;
+  }
+  return name.replace(/^@/, '').split('/').join('-');
+}
+
+function detectPackDir(cwd, namespace, explicitPack) {
+  if (explicitPack) {
+    return path.isAbsolute(explicitPack) ? explicitPack : path.join(cwd, explicitPack);
+  }
+  const { links } = readLinks(cwd);
+  const matches = [];
+  for (const [name, dir] of Object.entries(links)) {
+    let derivedNs = namespace;
+    try {
+      const manifest = readYaml(path.join(dir, 'pack.yaml')) || {};
+      derivedNs = packNamespace(manifest.name || name);
+    } catch (e) {
+      derivedNs = packNamespace(name);
+    }
+    if (derivedNs === namespace) {
+      matches.push(dir);
+    }
+  }
+  if (matches.length === 1) {
+    return matches[0];
+  }
+  if (matches.length === 0) {
+    throw new Error(`Could not auto-detect a pack for namespace '${namespace}'. Pass --pack <dir>.`);
+  }
+  throw new Error(`Multiple linked packs match namespace '${namespace}'. Pass --pack <dir>.`);
+}
+
+function syncArea(areaRef, options) {
+  options = options || {};
+  const cwd = options.cwd || process.cwd();
+  const gameRoot = options.gameRoot || cwd;
+  const force = !!options.force;
+  const bumpLevel = options.bump || 'patch';
+  const keepSidecars = !!options.keepSidecars;
+
+  const colon = areaRef.indexOf(':');
+  if (colon < 1) {
+    throw new Error('Usage: sync-area <namespace:area-id> [--pack <dir>]');
+  }
+  const namespace = areaRef.slice(0, colon);
+  const area = areaRef.slice(colon + 1);
+
+  const sideCarRooms = path.join(gameRoot, 'data', 'areas', area, 'rooms');
+  if (!fs.existsSync(sideCarRooms)) {
+    throw new Error(`No authored rooms found for area '${area}' at ${sideCarRooms}`);
+  }
+  const files = fs.readdirSync(sideCarRooms).filter((f) => f.endsWith('.yaml'));
+  if (files.length === 0) {
+    throw new Error(`No authored rooms found for area '${area}'`);
+  }
+
+  const packDir = detectPackDir(cwd, namespace, options.pack);
+
+  const destManifestPath = path.join(packDir, 'pack.yaml');
+  if (!fs.existsSync(destManifestPath)) {
+    throw new Error(`No pack.yaml found in ${packDir}. sync-area targets an existing pack; pass --pack <dir> pointing at one.`);
+  }
+  const destManifest = readYaml(destManifestPath) || {};
+  if (!destManifest.name) {
+    throw new Error(`pack.yaml in ${packDir} has no 'name' field.`);
+  }
+  const destNamespace = packNamespace(destManifest.name);
+  if (destNamespace !== namespace) {
+    throw new Error(
+      `Pack namespace '${destNamespace}' does not match area namespace '${namespace}'. ` +
+      'sync-area only commits an area back into its own pack; use link (or a future migrate) for cross-pack moves.'
+    );
+  }
+
+  const targetRooms = path.join(packDir, 'areas', area, 'rooms');
+  fs.mkdirSync(targetRooms, { recursive: true });
+
+  const sideCarAreaYaml = path.join(gameRoot, 'data', 'areas', area, 'area.yaml');
+  const targetAreaYaml = path.join(packDir, 'areas', area, 'area.yaml');
+  if (fs.existsSync(sideCarAreaYaml)) {
+    // Authored area.yaml already carries the full `area:` envelope (Spec A) — copy it home.
+    writeYaml(targetAreaYaml, readYaml(sideCarAreaYaml));
+  } else if (!fs.existsSync(targetAreaYaml)) {
+    // No authored or pack area.yaml — synthesize a minimal valid envelope so it strict-boots.
+    writeYaml(targetAreaYaml, {
+      area: { id: area, name: area, level_range: [1, 99], reset_interval: 300 },
+    });
+  }
+
+  let written = 0;
+  for (const file of files) {
+    const src = path.join(sideCarRooms, file);
+    const dest = path.join(targetRooms, file);
+    const incoming = readYaml(src);
+    if (fs.existsSync(dest) && !force) {
+      const existing = readYaml(dest);
+      if (JSON.stringify(existing) !== JSON.stringify(incoming)) {
+        throw new Error(
+          `Pack file ${dest} diverges from the side-car. Review the diff and re-run with --force to overwrite.`);
+      }
+    }
+    writeYaml(dest, incoming);
+    written++;
+  }
+
+  ensureContentGlobs(packDir);
+
+  const { old, new: next } = bumpVersion(packDir, bumpLevel);
+  let committed = false;
+  if (isRepo(packDir)) {
+    commitAll(packDir, `content(${area}): sync authored edits, bump ${old} -> ${next}`);
+    committed = true;
+  } else {
+    console.warn(`warn: ${packDir} is not a git repo; bumped to ${next} but did not commit.`);
+  }
+
+  // Move = delete the game-root side-cars now that the content is durably in the pack.
+  // Runs after the write/commit above. In the non-git fallback the content is written
+  // (not committed); deletion is still correct because the pack dir holds the files.
+  if (!keepSidecars) {
+    const areaSideCarDir = path.join(gameRoot, 'data', 'areas', area);
+    for (const file of files) {
+      fs.rmSync(path.join(sideCarRooms, file));
+    }
+    if (fs.existsSync(sideCarRooms) && fs.readdirSync(sideCarRooms).length === 0) {
+      fs.rmdirSync(sideCarRooms);
+    }
+    const sideCarAreaYamlToDelete = path.join(areaSideCarDir, 'area.yaml');
+    if (fs.existsSync(sideCarAreaYamlToDelete)) {
+      fs.rmSync(sideCarAreaYamlToDelete);
+    }
+    if (fs.existsSync(areaSideCarDir) && fs.readdirSync(areaSideCarDir).length === 0) {
+      fs.rmdirSync(areaSideCarDir);
+    }
+  }
+
+  console.log(`Synced ${written} room(s) for area '${area}' into ${packDir} (v${old} -> v${next}).`);
+  if (committed) {
+    console.log('To publish + deploy, push the pack repo:');
+    console.log(`  cd ${packDir} && git push`);
+  }
+}
+
+module.exports = { syncArea, exportArea: syncArea, packNamespace, detectPackDir };

package/src/commands/update.js

@@ -53,7 +53,14 @@ async function update(packageArg, { cwd = process.cwd(), registryUrl = DEFAULT_R
 
     const destDir = packInstallPath(cwd, packageName);
     if (fs.existsSync(destDir)) {
-      fs.rmSync(destDir, { recursive: true });
+      try {
+        fs.rmSync(destDir, { recursive: true });
+      } catch (e) {
+        throw new Error(
+          `could not replace ${packageName} at ${destDir}: ${e.message}. ` +
+          `The user running tapestry may not own the packs directory.`
+        );
+      }
     }
 
     const safeId = packageName.replace('@', '').replace('/', '-');

package/src/lib/engine-manager.js

@@ -66,7 +66,7 @@ function dockerEnsureImage(image, version) {
   }
 }
 
-function dockerStart(projectName, image, version, packsDir, serverYamlPath, dataDir, network, linkMounts = []) {
+function dockerStart(projectName, image, version, packsDir, serverYamlPath, dataDir, network, linkMounts = [], envFile = null) {
   const containerName = `tapestry-${projectName}`;
   dockerEnsureImage(image, version);
   spawnSync('docker', ['rm', '-f', containerName], { stdio: 'ignore' });
@@ -80,6 +80,9 @@ function dockerStart(projectName, image, version, packsDir, serverYamlPath, data
     '-v', `${dataDir}:/app/data`,
     ...linkMounts,
   ];
+  if (envFile) {
+    args.push('--env-file', envFile);
+  }
   if (network) {
     args.push('--network', network);
   }
@@ -268,6 +271,7 @@ function readEngineConfig(cwd) {
     mode: engine.mode,
     image: engine.image || DEFAULT_IMAGE,
     network: engine.network || null,
+    envFile: engine.env_file || null,
     installDir: path.join(cwd, '.tapestry-engine'),
     projectName: (manifest.name || 'tapestry').toLowerCase().replace(/[^a-z0-9-]+/g, '-'),
   };
@@ -324,7 +328,17 @@ async function startEngine(cwd) {
   fs.mkdirSync(dataDir, { recursive: true });
   if (config.mode === 'docker') {
     const tag = await resolveDockerTag(config);
-    dockerStart(config.projectName, config.image, tag, packsDir, serverYamlPath, dataDir, config.network, dockerLinkMounts(cwd));
+    let envFile = null;
+    if (config.envFile) {
+      envFile = path.resolve(cwd, config.envFile);
+      if (!fs.existsSync(envFile)) {
+        throw new Error(
+          `engine.env_file '${config.envFile}' not found at ${envFile}. ` +
+          'The file must exist on the host running tapestry start.'
+        );
+      }
+    }
+    dockerStart(config.projectName, config.image, tag, packsDir, serverYamlPath, dataDir, config.network, dockerLinkMounts(cwd), envFile);
   } else if (config.mode === 'binary') {
     materializeLinks(cwd);
     binaryStart(config.version, config.installDir, packsDir, serverYamlPath, cwd);

package/src/lib/git.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const { spawnSync } = require('child_process');
+
+function isRepo(dir) {
+  const res = spawnSync('git', ['-C', dir, 'rev-parse', '--is-inside-work-tree'], { stdio: 'ignore' });
+  return res.status === 0;
+}
+
+// Stage everything in dir and commit. Throws on failure.
+function commitAll(dir, message) {
+  const add = spawnSync('git', ['-C', dir, 'add', '-A'], { stdio: 'ignore' });
+  if (add.status !== 0) {
+    throw new Error(`git add failed in ${dir}`);
+  }
+  const commit = spawnSync('git', ['-C', dir, 'commit', '-m', message], { stdio: 'ignore' });
+  if (commit.status !== 0) {
+    throw new Error(`git commit failed in ${dir}`);
+  }
+}
+
+module.exports = { isRepo, commitAll };

package/src/lib/pack-manifest.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const path = require('path');
+const semver = require('semver');
+const { readYaml, writeYaml } = require('../util/yaml');
+
+const CONTENT_GLOBS = {
+  area_definitions: 'areas/**/area.yaml',
+  rooms: 'areas/**/rooms/*.yaml',
+};
+
+// Additively ensure the pack manifest declares the given content globs.
+// Returns the list of keys that were added (empty if no change).
+function ensureContentGlobs(packDir, globs = CONTENT_GLOBS) {
+  const manifestPath = path.join(packDir, 'pack.yaml');
+  const manifest = readYaml(manifestPath) || {};
+  if (!manifest.content || typeof manifest.content !== 'object') {
+    manifest.content = {};
+  }
+  const added = [];
+  for (const [key, value] of Object.entries(globs)) {
+    if (!(key in manifest.content)) {
+      manifest.content[key] = value;
+      added.push(key);
+    }
+  }
+  if (added.length > 0) {
+    writeYaml(manifestPath, manifest);
+  }
+  return added;
+}
+
+// Bump the pack version (patch|minor|major). Returns { old, new }.
+function bumpVersion(packDir, level = 'patch') {
+  const manifestPath = path.join(packDir, 'pack.yaml');
+  const manifest = readYaml(manifestPath) || {};
+  const old = manifest.version;
+  if (!old || !semver.valid(old)) {
+    throw new Error(`pack.yaml has no valid semver version (found: ${old}). Cannot bump.`);
+  }
+  const next = semver.inc(old, level);
+  if (!next) {
+    throw new Error(`Invalid bump level '${level}'. Expected patch, minor, or major.`);
+  }
+  manifest.version = next;
+  writeYaml(manifestPath, manifest);
+  return { old, new: next };
+}
+
+module.exports = { ensureContentGlobs, bumpVersion, CONTENT_GLOBS };

package/src/scaffold/templates.js

@@ -7,9 +7,7 @@ version: "0.1.0"
 type: "module"        # core | module | world
 display_name: "TODO: Human-readable name"
 description: "TODO: One-line description for registry search"
-author:
-  name: "TODO: Your Name"
-  handle: "TODO: your-registry-handle"
+author: "TODO: Your Name"
 license: "MIT"
 
 # Packs default to public. Add \`private: true\` to restrict access to your
@@ -39,7 +37,7 @@ tags: "tags.yml"
 
 # Glob patterns -- the engine uses these to find your content
 content:
-  areas: "areas/**/area.yaml"
+  area_definitions: "areas/**/area.yaml"
   rooms: "areas/**/rooms/*.yaml"
   items: "areas/**/items/*.yaml"
   mobs: "areas/**/mobs/*.yaml"

package/src/schema/manifest.js

@@ -10,13 +10,7 @@ const PackageManifestSchema = z.object({
   type: z.enum(['core', 'module', 'world']),
   display_name: z.string().min(1),
   description: z.string().min(1),
-  author: z.union([
-    z.string().min(1),
-    z.object({
-      name: z.string().min(1),
-      handle: z.string().min(1),
-    }),
-  ]),
+  author: z.string().min(1),
   license: z.string().min(1),
   engine: z.string().min(1),
   validation: z.enum(['strict', 'lenient']),
@@ -52,6 +46,8 @@ const ProjectManifestSchema = z.object({
       version: z.string().min(1),
       mode: z.enum(['docker', 'binary', 'source']),
       image: z.string().optional(),
+      network: z.string().optional(),
+      env_file: z.string().optional(),
     }),
   ]),
   dependencies: z.record(z.string()).optional(),