wyvrnpm 1.1.1 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wyvrnpm",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "A simple, static-hosting-compatible C++ package manager",
   "keywords": [
     "c++",

package/src/commands/publish.js

@@ -8,6 +8,69 @@ const { readManifest } = require('../manifest');
 const { getProvider } = require('../providers');
 const { readConfig } = require('../config');
 
+/**
+ * Parse a .wyvrnignore file and return an array of pattern strings.
+ * Lines starting with '#' and blank lines are ignored.
+ */
+function loadIgnorePatterns(ignoreFile) {
+  if (!fs.existsSync(ignoreFile)) return [];
+  return fs
+    .readFileSync(ignoreFile, 'utf8')
+    .split(/\r?\n/)
+    .map((l) => l.trim())
+    .filter((l) => l.length > 0 && !l.startsWith('#'));
+}
+
+/**
+ * Convert a glob-style ignore pattern to a RegExp.
+ * Supports '*', '**', '?' wildcards and leading '/' to anchor to root.
+ */
+function patternToRegex(pattern) {
+  // A leading slash means "anchored to root"; strip it and keep the rest
+  const anchored = pattern.startsWith('/');
+  const p = anchored ? pattern.slice(1) : pattern;
+
+  let re = p
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&') // escape regex special chars
+    .replace(/\*\*/g, '\x00')              // placeholder for **
+    .replace(/\*/g, '[^/]*')              // * → match within segment
+    .replace(/\?/g, '[^/]')              // ? → single non-slash char
+    .replace(/\x00/g, '.*');             // ** → match across segments
+
+  // If anchored, match from the start; otherwise match any path segment
+  return anchored ? new RegExp(`^${re}(/|$)`) : new RegExp(`(^|/)${re}(/|$)`);
+}
+
+/**
+ * Recursively add files from `dir` into `zip`, skipping any path that
+ * matches one of the compiled ignore regexes.
+ *
+ * @param {AdmZip} zip
+ * @param {string} dir        Absolute path of the directory being zipped
+ * @param {string} base       Absolute path of the root publish directory
+ * @param {RegExp[]} ignoreRe Compiled ignore patterns
+ */
+function addFolderFiltered(zip, dir, base, ignoreRe) {
+  for (const entry of fs.readdirSync(dir)) {
+    const fullPath = path.join(dir, entry);
+    // Relative path from publish root, always using forward slashes
+    const relPath = path.relative(base, fullPath).replace(/\\/g, '/');
+
+    if (ignoreRe.some((re) => re.test(relPath))) {
+      console.log(`[wyvrn]   Ignoring: ${relPath}`);
+      continue;
+    }
+
+    const stat = fs.statSync(fullPath);
+    if (stat.isDirectory()) {
+      addFolderFiltered(zip, fullPath, base, ignoreRe);
+    } else {
+      const zipDir = path.dirname(relPath).replace(/\\/g, '/');
+      zip.addLocalFile(fullPath, zipDir === '.' ? '' : zipDir);
+    }
+  }
+}
+
 async function publish(argv) {
   let { source, profile, platform, path: publishPath, token, manifest: manifestArg } = argv;
 
@@ -74,12 +137,20 @@ async function publish(argv) {
     `[wyvrn] Publishing ${name}@${version} (${targetPlatform}) via ${provider.constructor.providerName} provider`,
   );
 
+  // Load .wyvrnignore patterns from the publish directory
+  const ignoreFile = path.join(srcDir, '.wyvrnignore');
+  const ignorePatterns = loadIgnorePatterns(ignoreFile);
+  const ignoreRe = ignorePatterns.map(patternToRegex);
+  if (ignorePatterns.length > 0) {
+    console.log(`[wyvrn] Loaded ${ignorePatterns.length} pattern(s) from .wyvrnignore`);
+  }
+
   // Build a temporary zip of the publish directory
   const tmpZipPath = path.join(os.tmpdir(), `wyvrnpm-${name}-${version}-${Date.now()}.zip`);
   try {
     console.log(`[wyvrn] Zipping ${srcDir} ...`);
     const zip = new AdmZip();
-    zip.addLocalFolder(srcDir);
+    addFolderFiltered(zip, srcDir, srcDir, ignoreRe);
     zip.writeZip(tmpZipPath);
 
     await provider.publish(

package/src/providers/file.js

@@ -43,11 +43,17 @@ class FileProvider extends BaseProvider {
   async publish(files, options) {
     const { source, platform, name, version } = options;
 
-    const destDir = path.join(this._resolvePath(source), platform, name, version);
+    const packageDir = path.join(this._resolvePath(source), platform, name);
+    const destDir = path.join(packageDir, version);
     fs.mkdirSync(destDir, { recursive: true });
 
     this._copy(files.manifest, path.join(destDir, 'wyvrn.json'));
     this._copy(files.zip, path.join(destDir, 'wyvrn.zip'));
+
+    // Write latest.json at the package root so consumers can resolve "latest"
+    const latestPath = path.join(packageDir, 'latest.json');
+    console.log(`[wyvrn]   → ${latestPath}`);
+    fs.writeFileSync(latestPath, JSON.stringify({ version }), 'utf8');
   }
 
   _copy(src, dest) {

package/src/providers/http.js

@@ -18,9 +18,13 @@ class HttpProvider extends BaseProvider {
     const { source, platform, name, version, token } = options;
     const base = source.replace(/\/$/, '');
     const urlBase = `${base}/${platform}/${name}/${version}`;
+    const packageBase = `${base}/${platform}/${name}`;
 
     await this._put(`${urlBase}/wyvrn.json`, files.manifest, 'application/json', token);
     await this._put(`${urlBase}/wyvrn.zip`, files.zip, 'application/zip', token);
+
+    // Write latest.json at the package root so consumers can resolve "latest"
+    await this._putBuffer(`${packageBase}/latest.json`, Buffer.from(JSON.stringify({ version })), 'application/json', token);
   }
 
   _put(url, filePath, contentType, token) {
@@ -58,6 +62,41 @@ class HttpProvider extends BaseProvider {
       req.end();
     });
   }
+
+  _putBuffer(url, buffer, contentType, token) {
+    return new Promise((resolve, reject) => {
+      const parsed = new URL(url);
+      const lib = parsed.protocol === 'https:' ? https : http;
+
+      const headers = {
+        'Content-Type': contentType,
+        'Content-Length': buffer.length,
+      };
+      if (token) headers['Authorization'] = `Bearer ${token}`;
+
+      console.log(`[wyvrn]   → PUT ${url}`);
+      const req = lib.request(
+        {
+          hostname: parsed.hostname,
+          port: parsed.port || undefined,
+          path: parsed.pathname,
+          method: 'PUT',
+          headers,
+        },
+        (res) => {
+          res.resume();
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resolve();
+          } else {
+            reject(new Error(`HTTP PUT ${url} failed: ${res.statusCode} ${res.statusMessage}`));
+          }
+        },
+      );
+      req.on('error', reject);
+      req.write(buffer);
+      req.end();
+    });
+  }
 }
 
 module.exports = HttpProvider;

package/src/providers/s3.js

@@ -67,12 +67,18 @@ class S3Provider extends BaseProvider {
 
     // Destination key base:  [prefix/]platform/name/version
     const keyBase = [prefix, platform, name, version].filter(Boolean).join('/');
+    // Package root (without version) for latest.json
+    const packageBase = [prefix, platform, name].filter(Boolean).join('/');
 
     const clientConfig = profile ? { credentials: fromSSO({ profile }) } : {};
     const client = new S3Client(clientConfig);
 
     await this._put(client, bucket, `${keyBase}/wyvrn.json`, files.manifest, 'application/json', PutObjectCommand);
     await this._put(client, bucket, `${keyBase}/wyvrn.zip`, files.zip, 'application/zip', PutObjectCommand);
+
+    // Write latest.json at the package root so consumers can resolve "latest"
+    const latestContent = Buffer.from(JSON.stringify({ version }));
+    await this._putBuffer(client, bucket, `${packageBase}/latest.json`, latestContent, 'application/json', PutObjectCommand);
   }
 
   async _put(client, bucket, key, filePath, contentType, PutObjectCommand) {
@@ -86,6 +92,18 @@ class S3Provider extends BaseProvider {
       }),
     );
   }
+
+  async _putBuffer(client, bucket, key, content, contentType, PutObjectCommand) {
+    console.log(`[wyvrn]   → s3://${bucket}/${key}`);
+    await client.send(
+      new PutObjectCommand({
+        Bucket: bucket,
+        Key: key,
+        Body: content,
+        ContentType: contentType,
+      }),
+    );
+  }
 }
 
 module.exports = S3Provider;

package/src/resolve.js

@@ -22,6 +22,36 @@ function compareVersions(a, b) {
   return 0;
 }
 
+/**
+ * Resolves the "latest" tag for a package by fetching latest.json from the registry.
+ *
+ * @param {string} name
+ * @param {string[]} packageSources
+ * @param {string} platform
+ * @param {Function} httpClient
+ * @returns {Promise<string>} The resolved version string.
+ */
+async function resolveLatestVersion(name, packageSources, platform, httpClient) {
+  for (const source of packageSources) {
+    const base = source.replace(/\/$/, '');
+    const candidates = [
+      `${base}/${platform}/${name}/latest.json`,
+      `${base}/common/${name}/latest.json`,
+    ];
+    for (const url of candidates) {
+      try {
+        const response = await httpClient(url);
+        if (!response.ok) continue;
+        const data = await response.json();
+        if (data && data.version) return data.version;
+      } catch {
+        // Try next candidate.
+      }
+    }
+  }
+  throw new Error(`Could not resolve "latest" version for "${name}" from any source`);
+}
+
 /**
  * Fetches razer.json for a single package from the first source that responds.
  *
@@ -96,6 +126,17 @@ async function resolveDependencies(rootDeps, packageSources, platform, httpClien
       version = lockedVersions.get(name);
     }
 
+    // Resolve the "latest" tag to a concrete version before proceeding.
+    if (version === 'latest') {
+      try {
+        version = await resolveLatestVersion(name, packageSources, platform, httpClient);
+        console.log(`[wyvrn] Resolved "${name}@latest" → ${version}`);
+      } catch (err) {
+        console.warn(`[wyvrn] Warning: ${err.message}`);
+        continue;
+      }
+    }
+
     if (resolved.has(name)) {
       const existing = resolved.get(name);
       if (existing === version) {
@@ -154,5 +195,6 @@ async function resolveDependencies(rootDeps, packageSources, platform, httpClien
 
 module.exports = {
   compareVersions,
+  resolveLatestVersion,
   resolveDependencies,
 };