wyvrnpm 1.1.2 → 1.2.1

package/bin/wyvrn.js

@@ -86,6 +86,12 @@ yargs
         .option('token', {
           type: 'string',
           description: 'Bearer token for HTTP server authentication (HTTP only)',
+        })
+        .option('force', {
+          alias: 'f',
+          type: 'boolean',
+          description: 'Overwrite an existing published version',
+          default: false,
         });
     },
     (argv) => publish(argv),

package/package.json

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

package/src/commands/publish.js

@@ -72,7 +72,7 @@ function addFolderFiltered(zip, dir, base, ignoreRe) {
 }
 
 async function publish(argv) {
-  let { source, profile, platform, path: publishPath, token, manifest: manifestArg } = argv;
+  let { source, profile, platform, path: publishPath, token, manifest: manifestArg, force } = argv;
 
   // Resolve source + auth: CLI > config entry by name > first config entry > raw URL
   if (source) {
@@ -137,6 +137,19 @@ async function publish(argv) {
     `[wyvrn] Publishing ${name}@${version} (${targetPlatform}) via ${provider.constructor.providerName} provider`,
   );
 
+  // Prevent overwriting an already-published version unless --force is passed
+  const alreadyExists = await provider.exists({ source, platform: targetPlatform, name, version, profile, token });
+  if (alreadyExists) {
+    if (force) {
+      console.warn(`[wyvrn] Warning: ${name}@${version} already exists — overwriting (--force)`);
+    } else {
+      console.error(
+        `[wyvrn] Error: ${name}@${version} already exists. Bump the version or use --force to overwrite.`,
+      );
+      process.exit(1);
+    }
+  }
+
   // Load .wyvrnignore patterns from the publish directory
   const ignoreFile = path.join(srcDir, '.wyvrnignore');
   const ignorePatterns = loadIgnorePatterns(ignoreFile);

package/src/providers/base.js

@@ -36,6 +36,17 @@ class BaseProvider {
     throw new Error(`publish() is not implemented in ${this.constructor.name}`);
   }
 
+  /**
+   * Returns true if the given package version already exists at the destination.
+   * Providers should override this; the default assumes it does not exist.
+   *
+   * @param {{ source: string, platform: string, name: string, version: string, profile?: string, token?: string }} _options
+   * @returns {Promise<boolean>}
+   */
+  async exists(_options) {
+    return false;
+  }
+
   /** Human-readable provider name shown in log output. */
   static get providerName() {
     return 'BaseProvider';

package/src/providers/file.js

@@ -40,14 +40,26 @@ class FileProvider extends BaseProvider {
     return path.resolve(source);
   }
 
+  async exists(options) {
+    const { source, platform, name, version } = options;
+    const destDir = path.join(this._resolvePath(source), platform, name, version);
+    return fs.existsSync(path.join(destDir, 'wyvrn.json'));
+  }
+
   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

@@ -14,13 +14,33 @@ class HttpProvider extends BaseProvider {
     return 'HTTP';
   }
 
+  async exists(options) {
+    const { source, platform, name, version } = options;
+    const base = source.replace(/\/$/, '');
+    const url = `${base}/${platform}/${name}/${version}/wyvrn.json`;
+    return new Promise((resolve, reject) => {
+      const parsed = new URL(url);
+      const lib = parsed.protocol === 'https:' ? https : http;
+      const req = lib.request(
+        { hostname: parsed.hostname, port: parsed.port || undefined, path: parsed.pathname, method: 'HEAD' },
+        (res) => { res.resume(); resolve(res.statusCode >= 200 && res.statusCode < 300); },
+      );
+      req.on('error', reject);
+      req.end();
+    });
+  }
+
   async publish(files, options) {
     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 +78,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

@@ -49,6 +49,33 @@ class S3Provider extends BaseProvider {
     };
   }
 
+  async exists(options) {
+    let S3Client, HeadObjectCommand, fromSSO;
+    try {
+      ({ S3Client, HeadObjectCommand } = require('@aws-sdk/client-s3'));
+      ({ fromSSO } = require('@aws-sdk/credential-providers'));
+    } catch {
+      throw new Error(
+        'AWS SDK packages are required for S3 publishing.\n' +
+          'Run: npm install @aws-sdk/client-s3 @aws-sdk/credential-providers',
+      );
+    }
+
+    const { source, platform, name, version, profile } = options;
+    const { bucket, prefix } = this._parseSource(source);
+    const key = [prefix, platform, name, version, 'wyvrn.json'].filter(Boolean).join('/');
+
+    const clientConfig = profile ? { credentials: fromSSO({ profile }) } : {};
+    const client = new S3Client(clientConfig);
+    try {
+      await client.send(new HeadObjectCommand({ Bucket: bucket, Key: key }));
+      return true;
+    } catch (err) {
+      if (err.name === 'NotFound' || err.$metadata?.httpStatusCode === 404) return false;
+      throw err;
+    }
+  }
+
   async publish(files, options) {
     // Lazy-load AWS SDK so the tool works without it when only HTTP is used.
     let S3Client, PutObjectCommand, fromSSO;
@@ -67,12 +94,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 +119,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,
 };