@tapestry-mud/cli 0.1.0

package/src/commands/login.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const fetch = require('node-fetch');
+const { saveToken } = require('../lib/auth');
+const { DEFAULT_REGISTRY } = require('../lib/registry-client');
+const { createInterface, ask, askPassword } = require('../util/prompt');
+
+async function promptCredentials() {
+  const rl = createInterface();
+  try {
+    const email = await ask(rl, 'Email: ');
+    const password = await askPassword(rl, 'Password: ');
+    return { email, password };
+  } finally {
+    rl.close();
+  }
+}
+
+async function login({ email, password } = {}, { registryUrl = DEFAULT_REGISTRY } = {}) {
+  if (!email || !password) {
+    ({ email, password } = await promptCredentials());
+  }
+
+  const res = await fetch(`${registryUrl}/v1/auth/login`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ email, password }),
+  });
+
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw new Error(body.error || `Login failed (${res.status})`);
+  }
+
+  const { token } = await res.json();
+  saveToken(token);
+  console.log('Logged in.');
+}
+
+module.exports = { login };

package/src/commands/outdated.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const semver = require('semver');
+const { readLock } = require('../lib/lock-file');
+const { fetchPackageMetadata, DEFAULT_REGISTRY } = require('../lib/registry-client');
+
+async function outdated({ cwd = process.cwd(), registryUrl = DEFAULT_REGISTRY } = {}) {
+  const lock = readLock(cwd);
+  if (!lock || !lock.resolved || !Object.keys(lock.resolved).length) {
+    console.log('No packages installed.');
+    return;
+  }
+
+  const packages = Object.entries(lock.resolved);
+  const stale = [];
+
+  for (const [pkgName, resolved] of packages) {
+    let latestVersion;
+    try {
+      const data = await fetchPackageMetadata(pkgName, registryUrl);
+      latestVersion = data.versions?.[0]?.version;
+    } catch {
+      continue;
+    }
+    if (latestVersion && semver.gt(latestVersion, resolved.version)) {
+      stale.push({ name: pkgName, current: resolved.version, latest: latestVersion });
+    }
+  }
+
+  if (!stale.length) {
+    console.log('All packages are up to date.');
+    return;
+  }
+
+  const nameWidth = Math.max(7, ...stale.map((s) => s.name.length));
+  const curWidth = Math.max(7, ...stale.map((s) => s.current.length));
+  console.log(`${'PACKAGE'.padEnd(nameWidth)}  ${'CURRENT'.padEnd(curWidth)}  LATEST`);
+  for (const s of stale) {
+    console.log(`${s.name.padEnd(nameWidth)}  ${s.current.padEnd(curWidth)}  ${s.latest}`);
+  }
+}
+
+module.exports = { outdated };

package/src/commands/pack.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const path = require('path');
+const { readYaml } = require('../util/yaml');
+const { buildTarball, computeIntegrity } = require('../lib/tarball-builder');
+const { validate } = require('./validate');
+
+async function pack({ cwd = process.cwd() } = {}) {
+  validate({ cwd });
+
+  const manifest = readYaml(path.join(cwd, 'tapestry.yaml'));
+  const shortName = manifest.name.split('/')[1];
+  const outputPath = path.join(cwd, `${shortName}-${manifest.version}.tgz`);
+
+  console.log(`Packing ${manifest.name}@${manifest.version}...`);
+  await buildTarball(cwd, outputPath);
+
+  const integrity = computeIntegrity(outputPath);
+  console.log(`  ${path.basename(outputPath)}`);
+  console.log(`  integrity: ${integrity}`);
+  console.log('Done.');
+}
+
+module.exports = { pack };

package/src/commands/publish.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const fetch = require('node-fetch');
+const FormData = require('form-data');
+const { readYaml } = require('../util/yaml');
+const { validate } = require('./validate');
+const { buildTarball, computeIntegrity } = require('../lib/tarball-builder');
+const { requireToken } = require('../lib/auth');
+const { DEFAULT_REGISTRY } = require('../lib/registry-client');
+
+async function publish({ cwd = process.cwd(), registryUrl = DEFAULT_REGISTRY } = {}) {
+  validate({ cwd });
+
+  const manifest = readYaml(path.join(cwd, 'tapestry.yaml'));
+  const token = requireToken();
+
+  const shortName = manifest.name.split('/')[1];
+  const tmpPath = path.join(
+    os.tmpdir(),
+    `tapestry-publish-${shortName}-${manifest.version}.tgz`
+  );
+
+  try {
+    console.log(`Publishing ${manifest.name}@${manifest.version}...`);
+    await buildTarball(cwd, tmpPath);
+
+    const integrity = computeIntegrity(tmpPath);
+
+    const form = new FormData();
+    form.append('tarball', fs.createReadStream(tmpPath), {
+      filename: `${manifest.version}.tgz`,
+      contentType: 'application/gzip',
+    });
+    form.append('metadata', JSON.stringify({ ...manifest, integrity }));
+
+    const res = await fetch(`${registryUrl}/v1/publish`, {
+      method: 'POST',
+      headers: {
+        ...form.getHeaders(),
+        Authorization: `Bearer ${token}`,
+      },
+      body: form,
+    });
+
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      throw new Error(body.error || `Publish failed (${res.status})`);
+    }
+
+    const result = await res.json();
+    console.log(`  Published ${result.name}@${result.version}`);
+    console.log('Done.');
+  } finally {
+    if (fs.existsSync(tmpPath)) {
+      fs.unlinkSync(tmpPath);
+    }
+  }
+}
+
+module.exports = { publish };

package/src/commands/register.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const fetch = require('node-fetch');
+const { saveToken } = require('../lib/auth');
+const { DEFAULT_REGISTRY } = require('../lib/registry-client');
+const { createInterface, ask, askPassword } = require('../util/prompt');
+
+async function promptRegistration() {
+  const rl = createInterface();
+  try {
+    const handle = await ask(rl, 'Handle (lowercase, e.g. mallek): ');
+    const email = await ask(rl, 'Email: ');
+    const password = await askPassword(rl, 'Password: ');
+    return { handle, email, password };
+  } finally {
+    rl.close();
+  }
+}
+
+async function register({ handle, email, password } = {}, { registryUrl = DEFAULT_REGISTRY } = {}) {
+  if (!handle || !email || !password) {
+    ({ handle, email, password } = await promptRegistration());
+  }
+
+  const res = await fetch(`${registryUrl}/v1/auth/register`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ handle, email, password }),
+  });
+
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw new Error(body.error || `Registration failed (${res.status})`);
+  }
+
+  const { token } = await res.json();
+  saveToken(token);
+  console.log(`Registered as ${handle}. Logged in.`);
+}
+
+module.exports = { register };

package/src/commands/search.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const fetch = require('node-fetch');
+const { DEFAULT_REGISTRY } = require('../lib/registry-client');
+
+async function search(query, { registryUrl = DEFAULT_REGISTRY } = {}) {
+  if (!query || !query.trim()) {
+    throw new Error('Usage: tapestry search <query>');
+  }
+
+  const res = await fetch(
+    `${registryUrl}/v1/search?q=${encodeURIComponent(query.trim())}`,
+    undefined
+  );
+
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Search failed (${res.status}): ${body}`);
+  }
+
+  const { results } = await res.json();
+
+  if (!results.length) {
+    console.log('No results found.');
+    return;
+  }
+
+  const nameWidth = Math.max(4, ...results.map((r) => r.name.length));
+  const verWidth = Math.max(7, ...results.map((r) => (r.version || '').length));
+
+  console.log(
+    `${'NAME'.padEnd(nameWidth)}  ${'VERSION'.padEnd(verWidth)}  DESCRIPTION`
+  );
+  for (const r of results) {
+    console.log(
+      `${r.name.padEnd(nameWidth)}  ${(r.version || '').padEnd(verWidth)}  ${r.description || ''}`
+    );
+  }
+}
+
+module.exports = { search };

package/src/commands/start.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const { startEngine } = require('../lib/engine-manager');
+
+async function startCmd({ cwd = process.cwd() } = {}) {
+  await startEngine(cwd);
+}
+
+module.exports = { startCmd };

package/src/commands/stop.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const { stopEngine } = require('../lib/engine-manager');
+
+async function stopCmd({ cwd = process.cwd() } = {}) {
+  await stopEngine(cwd);
+}
+
+module.exports = { stopCmd };

package/src/commands/uninstall.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { readYaml, writeYaml } = require('../util/yaml');
+const { readLock, writeLock } = require('../lib/lock-file');
+const { removePackageFromBoot } = require('../lib/boot');
+
+function packInstallPath(cwd, packageName) {
+  const parts = packageName.split('/');
+  return path.join(cwd, 'packs', ...parts);
+}
+
+async function uninstall(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.');
+  }
+
+  const manifest = readYaml(manifestPath);
+  if (!manifest.dependencies || !manifest.dependencies[packageName]) {
+    throw new Error(`${packageName} is not in tapestry.yaml`);
+  }
+
+  const destDir = packInstallPath(cwd, packageName);
+  if (fs.existsSync(destDir)) {
+    fs.rmSync(destDir, { recursive: true });
+    console.log(`  removed ${packageName}`);
+  }
+
+  delete manifest.dependencies[packageName];
+  writeYaml(manifestPath, manifest);
+
+  const lock = readLock(cwd);
+  if (lock && lock.resolved) {
+    delete lock.resolved[packageName];
+    writeLock(cwd, lock);
+  }
+
+  removePackageFromBoot(cwd, packageName);
+
+  console.log(`Uninstalled ${packageName}.`);
+  console.log('Note: transitive dependencies are not automatically removed. Run `tapestry install` to refresh.');
+}
+
+module.exports = { uninstall };

package/src/commands/update.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { readYaml } = 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);
+}
+
+async function update(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);
+  const allDeps = manifest.dependencies || {};
+
+  let depsToResolve;
+  if (packageArg) {
+    if (!allDeps[packageArg]) {
+      throw new Error(`${packageArg} is not in tapestry.yaml`);
+    }
+    depsToResolve = { [packageArg]: allDeps[packageArg] };
+  } else {
+    depsToResolve = allDeps;
+  }
+
+  console.log('Resolving latest compatible versions...');
+  const freshResolved = await resolve(depsToResolve, registryUrl);
+
+  const existingLock = readLock(cwd);
+  const existingResolved = (existingLock && existingLock.resolved) || {};
+  const mergedResolved = Object.assign({}, existingResolved, freshResolved);
+
+  for (const [packageName, info] of Object.entries(freshResolved)) {
+    const currentVersion = existingResolved[packageName] && existingResolved[packageName].version;
+    if (currentVersion === info.version) {
+      console.log(`  up to date ${packageName}@${info.version}`);
+      continue;
+    }
+
+    console.log(`  updating ${packageName} ${currentVersion || 'not installed'} -> ${info.version}`);
+
+    const destDir = packInstallPath(cwd, packageName);
+    if (fs.existsSync(destDir)) {
+      fs.rmSync(destDir, { recursive: true });
+    }
+
+    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);
+  }
+
+  writeLock(cwd, { lockfile_version: 1, resolved: mergedResolved });
+  console.log('Done.');
+}
+
+module.exports = { update };

package/src/commands/validate.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { readYaml } = require('../util/yaml');
+const { validatePackageManifest } = require('../schema/manifest');
+
+function validate({ cwd = process.cwd() } = {}) {
+  const manifestPath = path.join(cwd, 'tapestry.yaml');
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error('No tapestry.yaml found in current directory');
+  }
+
+  const data = readYaml(manifestPath);
+  console.log(`Validating ${manifestPath}...`);
+
+  const result = validatePackageManifest(data);
+  if (!result.success) {
+    for (const issue of result.error.issues) {
+      const fieldPath = issue.path.join('.') || 'root';
+      console.log(`  error: ${fieldPath} - ${issue.message}`);
+    }
+    throw new Error(`${result.error.issues.length} validation error(s)`);
+  }
+
+  console.log(`  OK  ${data.name} v${data.version}`);
+}
+
+module.exports = { validate };

package/src/lib/auth.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const yaml = require('js-yaml');
+
+const RC_PATH = path.join(os.homedir(), '.tapestryrc');
+
+function loadToken() {
+  if (!fs.existsSync(RC_PATH)) {
+    return null;
+  }
+  try {
+    const data = yaml.load(fs.readFileSync(RC_PATH, 'utf8'));
+    return data?.token ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function saveToken(token) {
+  fs.writeFileSync(RC_PATH, yaml.dump({ token }, { lineWidth: -1 }), { mode: 0o600 });
+}
+
+function requireToken() {
+  const token = loadToken();
+  if (!token) {
+    throw new Error('Not logged in. Run: tapestry login');
+  }
+  return token;
+}
+
+module.exports = { RC_PATH, loadToken, saveToken, requireToken };

package/src/lib/boot.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { readYaml, writeYaml } = require('../util/yaml');
+
+const BOOT_FILE = 'tapestry-boot.yaml';
+
+function readBoot(cwd) {
+  const bootPath = path.join(cwd, BOOT_FILE);
+  if (!fs.existsSync(bootPath)) {
+    return { modules: [], packs: {} };
+  }
+  const data = readYaml(bootPath);
+  return { modules: data.modules || [], packs: data.packs || {} };
+}
+
+function writeBoot(cwd, boot) {
+  writeYaml(path.join(cwd, BOOT_FILE), boot);
+}
+
+function addPackageToBoot(cwd, packageName, manifest) {
+  const boot = readBoot(cwd);
+
+  if (!boot.packs[packageName]) {
+    boot.packs[packageName] = { enabled: true };
+  }
+
+  if (manifest.module && manifest.module.class) {
+    const alreadyPresent = boot.modules.some((m) => m.package === packageName);
+    if (!alreadyPresent) {
+      boot.modules.push({
+        class: manifest.module.class,
+        package: packageName,
+        enabled: true,
+      });
+    }
+  }
+
+  boot.modules = topoSort(boot.modules);
+  writeBoot(cwd, boot);
+}
+
+function removePackageFromBoot(cwd, packageName) {
+  const boot = readBoot(cwd);
+  delete boot.packs[packageName];
+  boot.modules = boot.modules.filter((m) => m.package !== packageName);
+  writeBoot(cwd, boot);
+}
+
+function enablePackage(cwd, packageName) {
+  const boot = readBoot(cwd);
+  if (!boot.packs[packageName]) {
+    throw new Error(`${packageName} is not installed`);
+  }
+  boot.packs[packageName].enabled = true;
+  for (const mod of boot.modules) {
+    if (mod.package === packageName) {
+      mod.enabled = true;
+    }
+  }
+  writeBoot(cwd, boot);
+}
+
+function disablePackage(cwd, packageName) {
+  const boot = readBoot(cwd);
+  if (!boot.packs[packageName]) {
+    throw new Error(`${packageName} is not installed`);
+  }
+  boot.packs[packageName].enabled = false;
+  for (const mod of boot.modules) {
+    if (mod.package === packageName) {
+      mod.enabled = false;
+    }
+  }
+  writeBoot(cwd, boot);
+}
+
+function topoSort(modules) {
+  const byClass = {};
+  for (const mod of modules) {
+    byClass[mod.class] = mod;
+  }
+
+  const visited = new Set();
+  const inStack = new Set();
+  const result = [];
+
+  function visit(mod) {
+    if (inStack.has(mod.class)) {
+      throw new Error(`Circular dependency in .NET module boot order involving: ${mod.class}`);
+    }
+    if (visited.has(mod.class)) {
+      return;
+    }
+    inStack.add(mod.class);
+    if (mod.after && byClass[mod.after]) {
+      visit(byClass[mod.after]);
+    }
+    inStack.delete(mod.class);
+    visited.add(mod.class);
+    result.push(mod);
+  }
+
+  for (const mod of modules) {
+    visit(mod);
+  }
+
+  return result;
+}
+
+module.exports = { readBoot, writeBoot, addPackageToBoot, removePackageFromBoot, enablePackage, disablePackage, topoSort };