@tapestry-mud/cli 0.1.0

package/src/lib/engine-manager.js

@@ -0,0 +1,294 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync, spawn } = require('child_process');
+const { readYaml } = require('../util/yaml');
+const { writePid, readPid, clearPid } = require('./process-tracker');
+
+const ENGINE_REPO = 'https://github.com/tapestry-mud/tapestry.git';
+const DEFAULT_IMAGE = 'ghcr.io/tapestry-mud/tapestry';
+const PLATFORM_MAP = { linux: 'linux', darwin: 'osx', win32: 'windows' };
+
+// ── Docker helpers ──────────────────────────────────────────────────────────
+
+function dockerPull(image, version) {
+  console.log(`Pulling ${image}:${version}...`);
+  const result = spawnSync('docker', ['pull', `${image}:${version}`], { stdio: 'inherit' });
+  if (result.status !== 0) {
+    console.log(`Tag ${version} not found, falling back to ${image}:latest...`);
+    const fallback = spawnSync('docker', ['pull', `${image}:latest`], { stdio: 'inherit' });
+    if (fallback.status !== 0) {
+      throw new Error(
+        `docker pull failed. Is Docker running and is ${image} a valid image?`
+      );
+    }
+    spawnSync('docker', ['tag', `${image}:latest`, `${image}:${version}`], { stdio: 'inherit' });
+    console.log(`Engine image ready: ${image}:${version} (from latest)`);
+    return;
+  }
+  console.log(`Engine image ready: ${image}:${version}`);
+}
+
+function dockerStart(projectName, image, version, packsDir, serverYamlPath) {
+  const containerName = `tapestry-${projectName}`;
+  const result = spawnSync('docker', [
+    'run', '--detach',
+    '--name', containerName,
+    '-p', '4000:4000',
+    '-p', '4001:4001',
+    '-v', `${packsDir}:/app/packs`,
+    '-v', `${serverYamlPath}:/app/server.yaml`,
+    `${image}:${version}`,
+  ], { stdio: 'inherit' });
+  if (result.status !== 0) {
+    throw new Error(
+      `docker run failed. Ensure the image exists and no container named '${containerName}' is already running.`
+    );
+  }
+  console.log(`Engine started. Container: ${containerName}`);
+  console.log('  Telnet:    telnet localhost 4000');
+  console.log('  WebSocket: ws://localhost:4001');
+}
+
+function dockerStop(projectName) {
+  const containerName = `tapestry-${projectName}`;
+  const result = spawnSync('docker', ['stop', containerName], { stdio: 'inherit' });
+  if (result.status !== 0) {
+    throw new Error(`Failed to stop container '${containerName}'. Is it running?`);
+  }
+  const rmResult = spawnSync('docker', ['rm', containerName], { stdio: 'inherit' });
+  if (rmResult.status !== 0) {
+    throw new Error(`Failed to remove container '${containerName}'.`);
+  }
+  console.log('Engine stopped.');
+}
+
+function dockerInfo(image, version) {
+  return { mode: 'docker', version, image: `${image}:${version}` };
+}
+
+// ── Binary helpers ──────────────────────────────────────────────────────────
+
+function binaryExecName() {
+  return process.platform === 'win32' ? 'Tapestry.exe' : 'Tapestry';
+}
+
+function binaryInstall(version, installDir) {
+  const platform = PLATFORM_MAP[process.platform] || 'linux';
+  const url =
+    `https://github.com/tapestry-mud/tapestry/releases/download/v${version}/tapestry-${platform}.tar.gz`;
+  const binDir = path.join(installDir, 'binary', version);
+  fs.mkdirSync(binDir, { recursive: true });
+  const tarPath = path.join(binDir, 'tapestry.tar.gz');
+
+  console.log(`Downloading Tapestry engine v${version} for ${platform}...`);
+  const dlResult = spawnSync('curl', ['-L', '-o', tarPath, url], { stdio: 'inherit' });
+  if (dlResult.status !== 0) {
+    throw new Error(
+      'Failed to download engine binary. Ensure curl is installed and the version exists on GitHub releases.'
+    );
+  }
+
+  const exResult = spawnSync('tar', ['-xzf', tarPath, '-C', binDir], { stdio: 'inherit' });
+  if (exResult.status !== 0) {
+    if (fs.existsSync(tarPath)) {
+      fs.unlinkSync(tarPath);
+    }
+    throw new Error('Failed to extract engine binary.');
+  }
+
+  if (fs.existsSync(tarPath)) {
+    fs.unlinkSync(tarPath);
+  }
+  console.log(`Engine installed to ${binDir}`);
+}
+
+function binaryStart(version, installDir, packsDir, serverYamlPath, cwd) {
+  const binDir = path.join(installDir, 'binary', version);
+  const execPath = path.join(binDir, binaryExecName());
+  if (!fs.existsSync(execPath)) {
+    throw new Error(
+      `Engine binary not found at ${execPath}. Run tapestry engine install first.`
+    );
+  }
+  const child = spawn(execPath, ['--packs', packsDir, '--config', serverYamlPath], {
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+  writePid(cwd, child.pid);
+  console.log(`Engine started (PID ${child.pid}).`);
+  console.log('  Telnet:    telnet localhost 4000');
+  console.log('  WebSocket: ws://localhost:4001');
+}
+
+function binaryInfo(version, installDir) {
+  const binDir = path.join(installDir, 'binary', version);
+  return { mode: 'binary', version, path: binDir, installed: fs.existsSync(binDir) };
+}
+
+// ── Source helpers ──────────────────────────────────────────────────────────
+
+function sourceInstall(installDir) {
+  const sourceDir = path.join(installDir, 'source');
+  if (fs.existsSync(sourceDir)) {
+    throw new Error(
+      `Engine source already exists at ${sourceDir}. Run tapestry engine update to pull changes.`
+    );
+  }
+  console.log('Cloning Tapestry engine source...');
+  const result = spawnSync('git', ['clone', ENGINE_REPO, sourceDir], { stdio: 'inherit' });
+  if (result.status !== 0) {
+    throw new Error('git clone failed. Check your network connection.');
+  }
+  console.log(`Engine source cloned to ${sourceDir}`);
+}
+
+function sourcePull(installDir) {
+  const sourceDir = path.join(installDir, 'source');
+  if (!fs.existsSync(sourceDir)) {
+    throw new Error('Engine source not found. Run tapestry engine install first.');
+  }
+  console.log('Pulling engine source updates...');
+  const result = spawnSync('git', ['-C', sourceDir, 'pull'], { stdio: 'inherit' });
+  if (result.status !== 0) {
+    throw new Error('git pull failed. Check your network connection.');
+  }
+  console.log('Engine source updated.');
+}
+
+function sourceStart(installDir, packsDir, serverYamlPath, cwd) {
+  const sourceDir = path.join(installDir, 'source');
+  if (!fs.existsSync(sourceDir)) {
+    throw new Error('Engine source not found. Run tapestry engine install first.');
+  }
+  const child = spawn(
+    'dotnet',
+    ['run', '--', '--packs', packsDir, '--config', serverYamlPath],
+    { cwd: sourceDir, detached: true, stdio: 'ignore' }
+  );
+  child.unref();
+  writePid(cwd, child.pid);
+  console.log(`Engine started via dotnet run (PID ${child.pid}).`);
+  console.log('  Telnet:    telnet localhost 4000');
+  console.log('  WebSocket: ws://localhost:4001');
+}
+
+function sourceInfo(version, installDir) {
+  const sourceDir = path.join(installDir, 'source');
+  return { mode: 'source', version, path: sourceDir, installed: fs.existsSync(sourceDir) };
+}
+
+// ── Shared process helpers ──────────────────────────────────────────────────
+
+function processStop(cwd) {
+  const pid = readPid(cwd);
+  if (!pid) {
+    throw new Error('Engine is not running (no .tapestry.pid found).');
+  }
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch (_e) {
+    // process already gone — clear the pid file and report success
+  }
+  clearPid(cwd);
+  console.log('Engine stopped.');
+}
+
+// ── Config reader ───────────────────────────────────────────────────────────
+
+function readEngineConfig(cwd) {
+  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);
+  const engine = manifest.engine;
+  if (!engine || typeof engine !== 'object') {
+    throw new Error(
+      'engine must be configured as an object in tapestry.yaml:\n' +
+      '  engine:\n    version: "3.1.0"\n    mode: "docker"'
+    );
+  }
+  if (!engine.version) {
+    throw new Error('engine.version is required in tapestry.yaml');
+  }
+  if (!['docker', 'binary', 'source'].includes(engine.mode)) {
+    throw new Error(
+      `engine.mode must be docker, binary, or source. Got: ${engine.mode}`
+    );
+  }
+  return {
+    version: engine.version,
+    mode: engine.mode,
+    image: engine.image || DEFAULT_IMAGE,
+    installDir: path.join(cwd, '.tapestry-engine'),
+    projectName: (manifest.name || 'tapestry').toLowerCase().replace(/[^a-z0-9-]+/g, '-'),
+  };
+}
+
+// ── Public API ──────────────────────────────────────────────────────────────
+
+async function installEngine(cwd) {
+  const config = readEngineConfig(cwd);
+  if (config.mode === 'docker') {
+    dockerPull(config.image, config.version);
+  } else if (config.mode === 'binary') {
+    binaryInstall(config.version, config.installDir);
+  } else {
+    sourceInstall(config.installDir);
+  }
+}
+
+async function updateEngine(cwd) {
+  const config = readEngineConfig(cwd);
+  if (config.mode === 'docker') {
+    dockerPull(config.image, config.version);
+  } else if (config.mode === 'binary') {
+    binaryInstall(config.version, config.installDir);
+  } else {
+    sourcePull(config.installDir);
+  }
+}
+
+function getEngineInfo(cwd) {
+  const config = readEngineConfig(cwd);
+  if (config.mode === 'docker') {
+    return dockerInfo(config.image, config.version);
+  }
+  if (config.mode === 'binary') {
+    return binaryInfo(config.version, config.installDir);
+  }
+  return sourceInfo(config.version, config.installDir);
+}
+
+async function startEngine(cwd) {
+  const config = readEngineConfig(cwd);
+  const packsDir = path.resolve(cwd, 'packs');
+  const serverYamlPath = path.resolve(cwd, 'server.yaml');
+  if (!fs.existsSync(packsDir)) {
+    throw new Error('packs/ directory not found. Run tapestry install first.');
+  }
+  if (!fs.existsSync(serverYamlPath)) {
+    throw new Error('server.yaml not found in the current directory.');
+  }
+  if (config.mode === 'docker') {
+    dockerStart(config.projectName, config.image, config.version, packsDir, serverYamlPath);
+  } else if (config.mode === 'binary') {
+    binaryStart(config.version, config.installDir, packsDir, serverYamlPath, cwd);
+  } else {
+    sourceStart(config.installDir, packsDir, serverYamlPath, cwd);
+  }
+}
+
+async function stopEngine(cwd) {
+  const config = readEngineConfig(cwd);
+  if (config.mode === 'docker') {
+    dockerStop(config.projectName);
+  } else {
+    processStop(cwd);
+  }
+}
+
+module.exports = { installEngine, updateEngine, getEngineInfo, startEngine, stopEngine };

package/src/lib/lock-file.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { readYaml, writeYaml } = require('../util/yaml');
+
+const LOCK_FILE = 'tapestry-lock.yaml';
+
+function readLock(cwd) {
+  const lockPath = path.join(cwd, LOCK_FILE);
+  if (!fs.existsSync(lockPath)) {
+    return null;
+  }
+  return readYaml(lockPath);
+}
+
+function writeLock(cwd, lock) {
+  writeYaml(path.join(cwd, LOCK_FILE), lock);
+}
+
+module.exports = { readLock, writeLock };

package/src/lib/process-tracker.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const PID_FILE = '.tapestry.pid';
+
+function writePid(cwd, pid) {
+  fs.writeFileSync(path.join(cwd, PID_FILE), String(pid), 'utf8');
+}
+
+function readPid(cwd) {
+  const pidFile = path.join(cwd, PID_FILE);
+  if (!fs.existsSync(pidFile)) {
+    return null;
+  }
+  const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+  return isNaN(pid) || pid <= 0 ? null : pid;
+}
+
+function clearPid(cwd) {
+  const pidFile = path.join(cwd, PID_FILE);
+  if (fs.existsSync(pidFile)) {
+    fs.unlinkSync(pidFile);
+  }
+}
+
+module.exports = { writePid, readPid, clearPid };

package/src/lib/registry-client.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const fetch = require('node-fetch');
+
+const DEFAULT_REGISTRY = process.env.TAPESTRY_REGISTRY || 'https://registry.tapestryengine.com';
+
+function validatePackageName(name) {
+  if (!name || typeof name !== 'string') {
+    throw new Error('Package name must be a non-empty string');
+  }
+  if (!/^@[a-z0-9-]+\/[a-z0-9-]+/.test(name)) {
+    throw new Error(`Invalid package name: ${name}. Expected @scope/name format`);
+  }
+  if (name.includes('..') || name.includes('//')) {
+    throw new Error(`Invalid package name: ${name}. Path traversal not allowed`);
+  }
+}
+
+async function fetchPackageMetadata(name, registryUrl = DEFAULT_REGISTRY) {
+  validatePackageName(name);
+  const url = `${registryUrl}/v1/packages/${name}`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    if (res.status === 404) {
+      throw new Error(`Package ${name} not found in registry`);
+    }
+    const body = await res.text();
+    throw new Error(`Registry error ${res.status}: ${body}`);
+  }
+  try {
+    return await res.json();
+  } catch (e) {
+    throw new Error(`Invalid JSON response from registry for ${name}`);
+  }
+}
+
+async function fetchTarball(url) {
+  const res = await fetch(url);
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Tarball download failed: ${res.status}: ${body}`);
+  }
+  return res.buffer();
+}
+
+module.exports = { fetchPackageMetadata, fetchTarball, DEFAULT_REGISTRY };

package/src/lib/semver-resolver.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const semver = require('semver');
+const { fetchPackageMetadata } = require('./registry-client');
+
+async function resolve(dependencies, registryUrl) {
+  if (!dependencies || Object.keys(dependencies).length === 0) {
+    return {};
+  }
+
+  const baseUrl = registryUrl.replace(/\/$/, '');
+
+  const resolved = {};
+  const resolvedBy = {};
+  const queue = Object.entries(dependencies).map(([name, range]) => ({
+    name,
+    range,
+    requiredBy: 'root',
+  }));
+
+  while (queue.length > 0) {
+    const { name, range, requiredBy } = queue.shift();
+
+    if (resolved[name]) {
+      if (!semver.satisfies(resolved[name].version, range)) {
+        throw new Error(
+          `CONFLICT: ${resolvedBy[name].requiredBy} requires ${name}@${resolvedBy[name].range}\n` +
+          `          ${requiredBy} requires ${name}@${range}\n` +
+          `          No version satisfies both ranges.`
+        );
+      }
+      continue;
+    }
+
+    resolvedBy[name] = { range, requiredBy };
+
+    const meta = await fetchPackageMetadata(name, baseUrl);
+    const versions = meta.versions.map((v) => v.version);
+    const best = semver.maxSatisfying(versions, range);
+
+    if (!best) {
+      throw new Error(
+        `No version of ${name} satisfies ${range}. Available: ${versions.join(', ') || 'none'}`
+      );
+    }
+
+    const versionData = meta.versions.find((v) => v.version === best);
+    const manifest =
+      typeof versionData.manifest === 'string'
+        ? JSON.parse(versionData.manifest)
+        : versionData.manifest;
+
+    resolved[name] = {
+      version: best,
+      integrity: versionData.integrity,
+      tarball: `${baseUrl}/v1/packages/${name}/${best}.tgz`,
+    };
+
+    const transDeps = manifest.dependencies || {};
+    for (const [depName, depRange] of Object.entries(transDeps)) {
+      queue.push({ name: depName, range: depRange, requiredBy: `${name}@${best}` });
+    }
+
+    const peerDeps = manifest.peerDependencies || {};
+    for (const [peerName, peerRange] of Object.entries(peerDeps)) {
+      if (!resolved[peerName] && !dependencies[peerName]) {
+        console.warn(`  warn: optional peer ${peerName}@${peerRange} not installed`);
+      }
+    }
+  }
+
+  return resolved;
+}
+
+module.exports = { resolve };

package/src/lib/tarball-builder.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const tar = require('tar');
+
+const EXCLUDE = new Set(['.git', 'node_modules', '.DS_Store']);
+
+function shouldInclude(filePath) {
+  if (filePath.endsWith('.tgz')) {
+    return false;
+  }
+  return !filePath.split('/').some((part) => EXCLUDE.has(part));
+}
+
+async function buildTarball(packDir, outputPath) {
+  await tar.create(
+    {
+      file: outputPath,
+      gzip: true,
+      cwd: packDir,
+      prefix: 'package',
+      filter: (p) => shouldInclude(p),
+    },
+    ['.']
+  );
+}
+
+function computeIntegrity(filePath) {
+  const data = fs.readFileSync(filePath);
+  const hash = crypto.createHash('sha256').update(data).digest('base64');
+  return `sha256-${hash}`;
+}
+
+module.exports = { buildTarball, computeIntegrity };

package/src/lib/tarball.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const tar = require('tar');
+
+function verifyIntegrity(buffer, expected) {
+  const hash = crypto.createHash('sha256').update(buffer).digest('base64');
+  const computed = `sha256-${hash}`;
+  if (computed !== expected) {
+    throw new Error(
+      `Integrity check failed\n  expected: ${expected}\n  got:      ${computed}`
+    );
+  }
+}
+
+function saveTarball(buffer, destPath) {
+  fs.writeFileSync(destPath, buffer);
+}
+
+async function extractTarball(tarballPath, destDir) {
+  fs.mkdirSync(destDir, { recursive: true });
+  await tar.extract({ file: tarballPath, cwd: destDir, strip: 1 });
+}
+
+module.exports = { verifyIntegrity, saveTarball, extractTarball };