@tapestry-mud/cli 0.1.0

package/bin/tapestry.js

@@ -0,0 +1,288 @@
+#!/usr/bin/env node
+'use strict';
+
+const { Command } = require('commander');
+const { init } = require('../src/commands/init');
+const { createPack } = require('../src/commands/create-pack');
+const { install } = require('../src/commands/install');
+const { uninstall } = require('../src/commands/uninstall');
+const { update } = require('../src/commands/update');
+const { enable } = require('../src/commands/enable');
+const { disable } = require('../src/commands/disable');
+const { login } = require('../src/commands/login');
+const { register } = require('../src/commands/register');
+const { validate } = require('../src/commands/validate');
+const { pack } = require('../src/commands/pack');
+const { publish } = require('../src/commands/publish');
+const { search } = require('../src/commands/search');
+const { info } = require('../src/commands/info');
+const { list } = require('../src/commands/list');
+const { outdated } = require('../src/commands/outdated');
+const { engineInstall, engineUpdate, engineInfo } = require('../src/commands/engine');
+const { startCmd } = require('../src/commands/start');
+const { stopCmd } = require('../src/commands/stop');
+
+const program = new Command();
+
+program
+  .name('tapestry')
+  .description('Tapestry Package Manager')
+  .version('0.1.0');
+
+program
+  .command('init')
+  .description('Initialize a new Tapestry game project in the current directory')
+  .action(() => {
+    try {
+      init();
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+const createCmd = program.command('create');
+
+createCmd
+  .command('pack <name>')
+  .description('Scaffold a new pack with annotated example content')
+  .action((name) => {
+    try {
+      createPack(name);
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('install [package]')
+  .description('Install a package or all dependencies from tapestry.yaml')
+  .action(async (pkg) => {
+    try {
+      await install(pkg || undefined);
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('uninstall <package>')
+  .description('Remove an installed package')
+  .action(async (pkg) => {
+    try {
+      await uninstall(pkg);
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('update [package]')
+  .description('Update a package or all packages to latest compatible versions')
+  .action(async (pkg) => {
+    try {
+      await update(pkg || undefined);
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('enable <package>')
+  .description('Activate a package in the engine boot order')
+  .action(async (pkg) => {
+    try {
+      await enable(pkg);
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('disable <package>')
+  .description('Remove a package from the engine boot order without deleting files')
+  .action(async (pkg) => {
+    try {
+      await disable(pkg);
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('login')
+  .description('Authenticate with the registry and store token in ~/.tapestryrc')
+  .action(async () => {
+    try {
+      await login();
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('register')
+  .description('Create an account on the registry')
+  .action(async () => {
+    try {
+      await register();
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('validate')
+  .description('Validate tapestry.yaml in the current directory')
+  .action(() => {
+    try {
+      validate();
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('pack')
+  .description('Build a tarball from the current pack directory for local inspection')
+  .action(async () => {
+    try {
+      await pack();
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('publish')
+  .description('Build and upload the current pack to the registry')
+  .action(async () => {
+    try {
+      await publish();
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('search <query>')
+  .description('Search the registry by keyword')
+  .action(async (query) => {
+    try {
+      await search(query);
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('info <package>')
+  .description('Show details for a registry package')
+  .action(async (pkg) => {
+    try {
+      await info(pkg);
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('list')
+  .description('Show installed packages with version, type, and enabled/disabled status')
+  .action(async () => {
+    try {
+      await list();
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('outdated')
+  .description('Show installed packages with newer versions available in the registry')
+  .action(async () => {
+    try {
+      await outdated();
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+const engineCmd = program.command('engine').description('Manage the Tapestry engine');
+
+engineCmd
+  .command('install')
+  .description('Fetch the engine artifact for the configured mode (docker/binary/source)')
+  .action(async () => {
+    try {
+      await engineInstall();
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+engineCmd
+  .command('update')
+  .description('Update the engine to the configured version')
+  .action(async () => {
+    try {
+      await engineUpdate();
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+engineCmd
+  .command('info')
+  .description('Show installed engine version, mode, and image or path')
+  .action(() => {
+    try {
+      engineInfo();
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('start')
+  .description('Launch the Tapestry engine')
+  .action(async () => {
+    try {
+      await startCmd();
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('stop')
+  .description('Stop the running Tapestry engine')
+  .action(async () => {
+    try {
+      await stopCmd();
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@tapestry-mud/cli",
+  "version": "0.1.0",
+  "description": "CLI for the Tapestry MUD engine",
+  "bin": {
+    "tapestry": "./bin/tapestry.js"
+  },
+  "scripts": {
+    "test": "jest"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "commander": "^11.1.0",
+    "form-data": "^4.0.5",
+    "js-yaml": "^4.1.0",
+    "node-fetch": "^2.7.0",
+    "semver": "^7.6.2",
+    "tar": "^6.2.1",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
+  }
+}

package/src/commands/create-pack.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { generatePackFiles } = require('../scaffold/templates');
+
+function parseName(name) {
+  const scopedMatch = name.match(/^@([a-z0-9-]+)\/([a-z0-9-]+)$/);
+  if (scopedMatch) {
+    {
+      return { scopedName: name, shortName: scopedMatch[2], scope: scopedMatch[1] };
+    }
+  }
+  const plainMatch = name.match(/^[a-z0-9-]+$/);
+  if (plainMatch) {
+    {
+      return { scopedName: `@todo/${name}`, shortName: name, scope: 'todo' };
+    }
+  }
+  return null;
+}
+
+function createPack(name, cwd) {
+  {
+    if (cwd === undefined) {
+      {
+        cwd = process.cwd();
+      }
+    }
+    const parsed = parseName(name);
+    if (!parsed) {
+      {
+        throw new Error(
+          `Invalid pack name: ${name}\n` +
+          'Expected @scope/name or plain-name (lowercase letters and hyphens only)'
+        );
+      }
+    }
+
+    const packDir = path.join(cwd, parsed.shortName);
+    if (fs.existsSync(packDir)) {
+      {
+        throw new Error(`Directory already exists: ${packDir}`);
+      }
+    }
+
+    const files = generatePackFiles(parsed);
+    for (const file of files) {
+      {
+        const filePath = path.join(packDir, file.path);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, file.content);
+      }
+    }
+
+    console.log(`Created pack: ${parsed.scopedName}`);
+    for (const file of files) {
+      {
+        console.log(`  ${file.path}`);
+      }
+    }
+    console.log('\nEdit tapestry.yaml, then run: tapestry validate');
+  }
+}
+
+module.exports = { createPack, parseName };

package/src/commands/disable.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { disablePackage } = require('../lib/boot');
+
+async function disable(packageName, { cwd = process.cwd() } = {}) {
+  const manifestPath = path.join(cwd, 'tapestry.yaml');
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error('No tapestry.yaml found. Run `tapestry init` first.');
+  }
+  disablePackage(cwd, packageName);
+  console.log(`Disabled ${packageName}. Files remain on disk. Run \`tapestry enable ${packageName}\` to re-activate.`);
+}
+
+module.exports = { disable };

package/src/commands/enable.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { enablePackage } = require('../lib/boot');
+
+async function enable(packageName, { cwd = process.cwd() } = {}) {
+  const manifestPath = path.join(cwd, 'tapestry.yaml');
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error('No tapestry.yaml found. Run `tapestry init` first.');
+  }
+  enablePackage(cwd, packageName);
+  console.log(`Enabled ${packageName}.`);
+}
+
+module.exports = { enable };

package/src/commands/engine.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const { installEngine, updateEngine, getEngineInfo } = require('../lib/engine-manager');
+
+async function engineInstall({ cwd = process.cwd() } = {}) {
+  await installEngine(cwd);
+}
+
+async function engineUpdate({ cwd = process.cwd() } = {}) {
+  await updateEngine(cwd);
+}
+
+function engineInfo({ cwd = process.cwd() } = {}) {
+  const info = getEngineInfo(cwd);
+  console.log(`Mode:    ${info.mode}`);
+  console.log(`Version: ${info.version}`);
+  if (info.mode === 'docker') {
+    console.log(`Image:   ${info.image}`);
+  } else {
+    console.log(`Path:    ${info.path}`);
+    console.log(`Status:  ${info.installed ? 'installed' : 'not installed'}`);
+  }
+}
+
+module.exports = { engineInstall, engineUpdate, engineInfo };

package/src/commands/info.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const { fetchPackageMetadata } = require('../lib/registry-client');
+
+async function info(packageName, { registryUrl } = {}) {
+  if (!packageName) {
+    throw new Error('Usage: tapestry info <package>');
+  }
+
+  const data = await fetchPackageMetadata(packageName, registryUrl);
+  const latest = data.versions?.[0];
+  const m = latest?.manifest || {};
+
+  console.log(data.name);
+  if (m.description) {
+    console.log(m.description);
+  }
+  console.log('');
+  if (m.author) {
+    console.log(`  Author:   ${typeof m.author === 'string' ? m.author : m.author.handle}`);
+  }
+  if (m.license) {
+    console.log(`  License:  ${m.license}`);
+  }
+  if (m.type) {
+    console.log(`  Type:     ${m.type}`);
+  }
+  if (latest?.version) {
+    console.log(`  Latest:   ${latest.version}`);
+  }
+
+  if (data.versions?.length > 1) {
+    console.log(`  Versions: ${data.versions.map((v) => v.version).join('  ')}`);
+  }
+
+  const deps = m.dependencies ? Object.entries(m.dependencies) : [];
+  if (deps.length) {
+    console.log('');
+    console.log('  Dependencies:');
+    for (const [dep, range] of deps) {
+      console.log(`    ${dep}  ${range}`);
+    }
+  }
+
+  if (m.meta?.keywords?.length) {
+    console.log('');
+    console.log(`  Keywords: ${m.meta.keywords.join(', ')}`);
+  }
+}
+
+module.exports = { info };

package/src/commands/init.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function buildManifest(name) {
+  return [
+    `name: ${name}`,
+    `engine:`,
+    `  version: '0.0.1'`,
+    `  mode: docker`,
+    `  image: ghcr.io/tapestry-mud/tapestry`,
+    `dependencies:`,
+    `  '@tapestry/core': '^0.0.1'`,
+    `  # Starter races, classes, and tutorial area. Remove or replace with your own content pack.`,
+    `  '@tapestry/example-pack': '^0.0.1'`,
+    `packs: []`,
+    `tag_validation: strict`,
+    ``,
+  ].join('\n');
+}
+
+function init(cwd) {
+  {
+    if (cwd === undefined) {
+      {
+        cwd = process.cwd();
+      }
+    }
+
+    const manifestPath = path.join(cwd, 'tapestry.yaml');
+    if (fs.existsSync(manifestPath)) {
+      {
+        throw new Error('tapestry.yaml already exists. Run tapestry install to install dependencies.');
+      }
+    }
+
+    const name = path.basename(cwd);
+    fs.writeFileSync(manifestPath, buildManifest(name));
+    fs.writeFileSync(path.join(cwd, 'server.yaml'), '# Tapestry server configuration\n# See https://tapestryengine.com/docs/config for full options\nport: 4000\n');
+    fs.mkdirSync(path.join(cwd, 'packs'), { recursive: true });
+    fs.writeFileSync(
+      path.join(cwd, '.gitignore'),
+      '# Installed packages (managed by tapestry install)\npacks/\n\n# Engine artifacts (managed by tapestry engine install)\n.tapestry-engine/\n'
+    );
+
+    console.log(`Initialized: ${name}`);
+    console.log('  tapestry.yaml  project manifest');
+    console.log('  server.yaml    engine config');
+    console.log('  packs/         installed packages');
+    console.log('  .gitignore     excludes packs/ and .tapestry-engine/ from git');
+
+    if (!fs.existsSync(path.join(cwd, '.git'))) {
+      {
+        console.log('\nHint: no git repo detected. Run: git init');
+      }
+    }
+
+    console.log('\nNext: run tapestry install, then tapestry engine install, then tapestry start');
+  }
+}
+
+module.exports = { init };

package/src/commands/install.js

@@ -0,0 +1,100 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { readYaml, writeYaml } = require('../util/yaml');
+const { resolve } = require('../lib/semver-resolver');
+const { readLock, writeLock } = require('../lib/lock-file');
+const { fetchTarball, DEFAULT_REGISTRY } = require('../lib/registry-client');
+const { verifyIntegrity, saveTarball, extractTarball } = require('../lib/tarball');
+const { addPackageToBoot } = require('../lib/boot');
+
+function packInstallPath(cwd, packageName) {
+  const parts = packageName.split('/');
+  return path.join(cwd, 'packs', ...parts);
+}
+
+function parsePackageArg(arg) {
+  const match = arg.match(/^(@[^@/]+\/[^@]+)(?:@(.+))?$/);
+  if (!match) {
+    throw new Error(`Invalid package name: ${arg}. Expected @scope/name or @scope/name@range`);
+  }
+  return { name: match[1], rawRange: match[2] || null };
+}
+
+function isLockCurrent(manifestDeps, lock) {
+  const lockResolved = lock.resolved || {};
+  return Object.keys(manifestDeps).every((name) => lockResolved[name]);
+}
+
+async function installResolved(cwd, resolved) {
+  for (const [packageName, info] of Object.entries(resolved)) {
+    const destDir = packInstallPath(cwd, packageName);
+
+    if (fs.existsSync(destDir)) {
+      console.log(`  already installed ${packageName}@${info.version}`);
+      continue;
+    }
+
+    console.log(`  installing ${packageName}@${info.version}`);
+
+    const safeId = packageName.replace('@', '').replace('/', '-');
+    const tmpPath = path.join(os.tmpdir(), `tapestry-${safeId}-${info.version}.tgz`);
+
+    try {
+      const buffer = await fetchTarball(info.tarball);
+      verifyIntegrity(buffer, info.integrity);
+      saveTarball(buffer, tmpPath);
+      await extractTarball(tmpPath, destDir);
+    } finally {
+      if (fs.existsSync(tmpPath)) {
+        fs.unlinkSync(tmpPath);
+      }
+    }
+
+    const packManifest = readYaml(path.join(destDir, 'tapestry.yaml'));
+    addPackageToBoot(cwd, packageName, packManifest);
+  }
+}
+
+async function install(packageArg, { cwd = process.cwd(), registryUrl = DEFAULT_REGISTRY } = {}) {
+  const manifestPath = path.join(cwd, 'tapestry.yaml');
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error('No tapestry.yaml found. Run `tapestry init` first.');
+  }
+
+  const manifest = readYaml(manifestPath);
+  let resolved;
+
+  if (packageArg) {
+    const { name, rawRange } = parsePackageArg(packageArg);
+    manifest.dependencies = manifest.dependencies || {};
+    const tempRange = rawRange || '*';
+    manifest.dependencies[name] = tempRange;
+
+    console.log('Resolving dependencies...');
+    resolved = await resolve(manifest.dependencies, registryUrl);
+
+    if (!rawRange) {
+      manifest.dependencies[name] = `^${resolved[name].version}`;
+    }
+
+    writeYaml(manifestPath, manifest);
+  } else {
+    const lock = readLock(cwd);
+    if (lock && isLockCurrent(manifest.dependencies || {}, lock)) {
+      console.log('Installing from lock file...');
+      resolved = lock.resolved;
+    } else {
+      console.log('Resolving dependencies...');
+      resolved = await resolve(manifest.dependencies || {}, registryUrl);
+    }
+  }
+
+  await installResolved(cwd, resolved);
+  writeLock(cwd, { lockfile_version: 1, resolved });
+  console.log('Done.');
+}
+
+module.exports = { install };

package/src/commands/list.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { readLock } = require('../lib/lock-file');
+const { readBoot } = require('../lib/boot');
+const { readYaml } = require('../util/yaml');
+
+function packInstallPath(cwd, packageName) {
+  const parts = packageName.split('/');
+  return path.join(cwd, 'packs', ...parts);
+}
+
+async function list({ cwd = process.cwd() } = {}) {
+  const lock = readLock(cwd);
+  if (!lock || !lock.resolved || !Object.keys(lock.resolved).length) {
+    console.log('No packages installed.');
+    return;
+  }
+
+  const boot = readBoot(cwd);
+  const packages = Object.entries(lock.resolved);
+
+  const nameWidth = Math.max(7, ...packages.map(([n]) => n.length));
+  const verWidth = Math.max(7, ...packages.map(([, r]) => r.version.length));
+
+  console.log(
+    `${'PACKAGE'.padEnd(nameWidth)}  ${'VERSION'.padEnd(verWidth)}  TYPE      STATUS`
+  );
+
+  for (const [pkgName, resolved] of packages) {
+    const enabled = boot.packs[pkgName]?.enabled !== false ? 'enabled' : 'disabled';
+
+    let type = '';
+    const packManifestPath = path.join(packInstallPath(cwd, pkgName), 'tapestry.yaml');
+    if (fs.existsSync(packManifestPath)) {
+      try {
+        type = readYaml(packManifestPath).type || '';
+      } catch {
+        //
+      }
+    }
+
+    console.log(
+      `${pkgName.padEnd(nameWidth)}  ${resolved.version.padEnd(verWidth)}  ${type.padEnd(8)}  ${enabled}`
+    );
+  }
+}
+
+module.exports = { list };