wyvrnpm 1.3.2 → 2.0.2

package/src/providers/s3.js

@@ -1,14 +1,28 @@
 'use strict';
 
 const fs = require('fs');
+const path = require('path');
 const BaseProvider = require('./base');
 
-// Matches:  s3://bucket/...
-const RE_S3_URI = /^s3:\/\//;
-// Matches:  https://bucket.s3.amazonaws.com/...  or  https://bucket.s3.us-east-1.amazonaws.com/...
+const RE_S3_URI           = /^s3:\/\//;
 const RE_S3_VIRTUAL_HOSTED = /^https?:\/\/([^.]+)\.s3[.-][^/]*\.amazonaws\.com/;
-// Matches:  https://s3.amazonaws.com/bucket/...  or  https://s3.us-east-1.amazonaws.com/bucket/...
-const RE_S3_PATH_STYLE = /^https?:\/\/s3[.-][^/]*\.amazonaws\.com\/([^/]+)/;
+const RE_S3_PATH_STYLE    = /^https?:\/\/s3[.-][^/]*\.amazonaws\.com\/([^/]+)/;
+
+function pinDependencies(rawDeps, lockedDeps) {
+  if (!rawDeps || !lockedDeps || Object.keys(lockedDeps).length === 0) return rawDeps;
+  const result = {};
+  for (const [pkgName, value] of Object.entries(rawDeps)) {
+    const locked = lockedDeps[pkgName];
+    if (locked) {
+      result[pkgName] = typeof value === 'object' && value !== null
+        ? { ...value, version: locked }
+        : locked;
+    } else {
+      result[pkgName] = value;
+    }
+  }
+  return result;
+}
 
 class S3Provider extends BaseProvider {
   static canHandle(source) {
@@ -23,50 +37,101 @@ class S3Provider extends BaseProvider {
     return 'S3';
   }
 
-  /** Parse source into { bucket, prefix }. prefix has no leading/trailing slashes. */
+  // ── helpers ──────────────────────────────────────────────────────────────
+
   _parseSource(source) {
     if (RE_S3_URI.test(source)) {
-      const rest = source.slice(5); // strip "s3://"
+      const rest  = source.slice(5);
       const slash = rest.indexOf('/');
       if (slash === -1) return { bucket: rest, prefix: '' };
-      return {
-        bucket: rest.slice(0, slash),
-        prefix: rest.slice(slash + 1).replace(/\/$/, ''),
-      };
+      return { bucket: rest.slice(0, slash), prefix: rest.slice(slash + 1).replace(/\/$/, '') };
     }
-
-    const url = new URL(source);
+    const url     = new URL(source);
     const vhMatch = url.hostname.match(/^([^.]+)\.s3/);
     if (vhMatch) {
       return { bucket: vhMatch[1], prefix: url.pathname.slice(1).replace(/\/$/, '') };
     }
-
-    // path-style: first path segment is the bucket
     const parts = url.pathname.slice(1).split('/');
-    return {
-      bucket: parts[0],
-      prefix: parts.slice(1).join('/').replace(/\/$/, ''),
-    };
+    return { bucket: parts[0], prefix: parts.slice(1).join('/').replace(/\/$/, '') };
+  }
+
+  _key(prefix, ...parts) {
+    return [prefix, ...parts].filter(Boolean).join('/');
   }
 
-  async exists(options) {
-    let S3Client, HeadObjectCommand, fromSSO;
+  _loadSdk() {
     try {
-      ({ S3Client, HeadObjectCommand } = require('@aws-sdk/client-s3'));
-      ({ fromSSO } = require('@aws-sdk/credential-providers'));
+      const { S3Client, PutObjectCommand, HeadObjectCommand, GetObjectCommand } =
+        require('@aws-sdk/client-s3');
+      const { fromSSO } = require('@aws-sdk/credential-providers');
+      return { S3Client, PutObjectCommand, HeadObjectCommand, GetObjectCommand, fromSSO };
     } 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('/');
+  _makeClient(awsProfile) {
+    const { S3Client, fromSSO } = this._loadSdk();
+    return new S3Client(awsProfile ? { credentials: fromSSO({ profile: awsProfile }) } : {});
+  }
 
-    const clientConfig = profile ? { credentials: fromSSO({ profile }) } : {};
-    const client = new S3Client(clientConfig);
+  async _putFile(client, bucket, key, filePath, contentType, PutObjectCommand) {
+    console.log(`[wyvrn]   → s3://${bucket}/${key}`);
+    await client.send(new PutObjectCommand({
+      Bucket: bucket, Key: key,
+      Body: fs.readFileSync(filePath),
+      ContentType: contentType,
+    }));
+  }
+
+  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,
+    }));
+  }
+
+  async _getJson(client, bucket, key, GetObjectCommand) {
+    try {
+      const resp = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+      const chunks = [];
+      for await (const chunk of resp.Body) chunks.push(chunk);
+      return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    } catch (err) {
+      if (err.name === 'NoSuchKey' || err.$metadata?.httpStatusCode === 404) return null;
+      throw err;
+    }
+  }
+
+  async _downloadToFile(client, bucket, key, destPath, GetObjectCommand) {
+    try {
+      const resp = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+      const out  = fs.createWriteStream(destPath);
+      await new Promise((resolve, reject) => {
+        resp.Body.pipe(out);
+        out.on('finish', resolve);
+        out.on('error', reject);
+        resp.Body.on('error', reject);
+      });
+      return true;
+    } catch (err) {
+      if (err.name === 'NoSuchKey' || err.$metadata?.httpStatusCode === 404) return false;
+      throw err;
+    }
+  }
+
+  // ── v1 (legacy) API ───────────────────────────────────────────────────────
+
+  async exists({ source, platform, name, version, awsProfile }) {
+    const { HeadObjectCommand } = this._loadSdk();
+    const client = this._makeClient(awsProfile);
+    const { bucket, prefix } = this._parseSource(source);
+    const key = this._key(prefix, platform, name, version, 'wyvrn.json');
     try {
       await client.send(new HeadObjectCommand({ Bucket: bucket, Key: key }));
       return true;
@@ -76,61 +141,133 @@ class S3Provider extends BaseProvider {
     }
   }
 
-  async publish(files, options) {
-    // Lazy-load AWS SDK so the tool works without it when only HTTP is used.
-    let S3Client, PutObjectCommand, fromSSO;
+  async publish(files, { source, platform, name, version, awsProfile }) {
+    const { PutObjectCommand } = this._loadSdk();
+    const client = this._makeClient(awsProfile);
+    const { bucket, prefix } = this._parseSource(source);
+
+    const keyBase     = this._key(prefix, platform, name, version);
+    const packageBase = this._key(prefix, platform, name);
+
+    await this._putFile(client, bucket, `${keyBase}/wyvrn.json`, files.manifest, 'application/json', PutObjectCommand);
+    await this._putFile(client, bucket, `${keyBase}/wyvrn.zip`,  files.zip,      'application/zip',  PutObjectCommand);
+    await this._putBuffer(
+      client, bucket, `${packageBase}/latest.json`,
+      Buffer.from(JSON.stringify({ version })), 'application/json', PutObjectCommand,
+    );
+  }
+
+  // ── v2 API ────────────────────────────────────────────────────────────────
+
+  async v2Exists({ source, name, version, profileHash, awsProfile }) {
+    const { HeadObjectCommand } = this._loadSdk();
+    const client = this._makeClient(awsProfile);
+    const { bucket, prefix } = this._parseSource(source);
+    const key = this._key(prefix, 'v2', name, version, profileHash, 'wyvrn.json');
     try {
-      ({ S3Client, PutObjectCommand } = 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',
-      );
+      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;
     }
+  }
 
-    const { source, platform, name, version, profile } = options;
+  async v2Publish(files, options) {
+    const {
+      source, name, version, profileHash, buildSettings,
+      contentSha256, gitSha, gitRepo, lockedDependencies, awsProfile,
+    } = options;
+    const { PutObjectCommand, GetObjectCommand } = this._loadSdk();
+    const client = this._makeClient(awsProfile);
     const { bucket, prefix } = this._parseSource(source);
 
-    // 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 v2root    = this._key(prefix, 'v2', name);
+    const buildRoot = `${v2root}/${version}/${profileHash}`;
 
-    const clientConfig = profile ? { credentials: fromSSO({ profile }) } : {};
-    const client = new S3Client(clientConfig);
+    // 1) Upload zip
+    await this._putFile(client, bucket, `${buildRoot}/wyvrn.zip`, files.zip, 'application/zip', PutObjectCommand);
 
-    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);
+    // 2) Upload enriched wyvrn.json
+    //    buildSettings is stored for debugging purposes only.
+    //    Dependencies are replaced with locked versions so the server never sees "latest".
+    const rawManifest = JSON.parse(fs.readFileSync(files.manifest, 'utf8'));
+    const pinnedDeps = pinDependencies(rawManifest.dependencies, lockedDependencies);
+    const v2Meta = {
+      ...rawManifest,
+      ...(pinnedDeps !== undefined ? { dependencies: pinnedDeps } : {}),
+      schemaVersion: 2,
+      profileHash,
+      buildSettings,
+      contentSha256,
+      gitSha:      gitSha  ?? null,
+      gitRepo:     gitRepo ?? null,
+      publishedAt: new Date().toISOString(),
+    };
+    await this._putBuffer(
+      client, bucket, `${buildRoot}/wyvrn.json`,
+      Buffer.from(JSON.stringify(v2Meta, null, 2)), 'application/json', 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);
-  }
+    // 3) source.json
+    if (gitSha || gitRepo) {
+      await this._putBuffer(
+        client, bucket, `${v2root}/${version}/source.json`,
+        Buffer.from(JSON.stringify({ gitRepo: gitRepo ?? null, gitSha: gitSha ?? null }, null, 2)),
+        'application/json', PutObjectCommand,
+      );
+    }
 
-  async _put(client, bucket, key, filePath, contentType, PutObjectCommand) {
-    console.log(`[wyvrn]   → s3://${bucket}/${key}`);
-    await client.send(
-      new PutObjectCommand({
-        Bucket: bucket,
-        Key: key,
-        Body: fs.readFileSync(filePath),
-        ContentType: contentType,
-      }),
+    // 4) Read-modify-write versions.json
+    let versionsIdx = await this._getJson(client, bucket, `${v2root}/versions.json`, GetObjectCommand)
+      ?? { name, latest: version, versions: {} };
+    if (!versionsIdx.versions) versionsIdx.versions = {};
+    if (!versionsIdx.versions[version]) versionsIdx.versions[version] = { profiles: {} };
+    versionsIdx.versions[version].profiles[profileHash] = {
+      contentSha256,
+      publishedAt: new Date().toISOString(),
+      buildSettings,
+    };
+    if (gitSha || gitRepo) {
+      versionsIdx.versions[version].source = { gitRepo: gitRepo ?? null, gitSha: gitSha ?? null };
+    }
+    versionsIdx.latest = version;
+    await this._putBuffer(
+      client, bucket, `${v2root}/versions.json`,
+      Buffer.from(JSON.stringify(versionsIdx, null, 2)), 'application/json', PutObjectCommand,
     );
-  }
 
-  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,
-      }),
+    // 5) latest.json
+    await this._putBuffer(
+      client, bucket, `${v2root}/latest.json`,
+      Buffer.from(JSON.stringify({ version, profileHash, contentSha256 })),
+      'application/json', PutObjectCommand,
     );
   }
+
+  async v2GetMeta({ source, name, version, profileHash, awsProfile }) {
+    const { GetObjectCommand } = this._loadSdk();
+    const client = this._makeClient(awsProfile);
+    const { bucket, prefix } = this._parseSource(source);
+    const key = this._key(prefix, 'v2', name, version, profileHash, 'wyvrn.json');
+    return this._getJson(client, bucket, key, GetObjectCommand);
+  }
+
+  async v2GetVersionsIndex({ source, name, awsProfile }) {
+    const { GetObjectCommand } = this._loadSdk();
+    const client = this._makeClient(awsProfile);
+    const { bucket, prefix } = this._parseSource(source);
+    const key = this._key(prefix, 'v2', name, 'versions.json');
+    return this._getJson(client, bucket, key, GetObjectCommand);
+  }
+
+  async v2DownloadZip({ source, name, version, profileHash, awsProfile }, destPath) {
+    const { GetObjectCommand } = this._loadSdk();
+    const client = this._makeClient(awsProfile);
+    const { bucket, prefix } = this._parseSource(source);
+    const key = this._key(prefix, 'v2', name, version, profileHash, 'wyvrn.zip');
+    return this._downloadToFile(client, bucket, key, destPath, GetObjectCommand);
+  }
 }
 
 module.exports = S3Provider;

package/src/resolve.js

@@ -73,9 +73,12 @@ function compareVersions(a, b) {
  * @returns {Promise<string>} The resolved version string.
  */
 async function resolveLatestVersion(name, packageSources, platform, httpClient) {
+  let best = null;
+
   for (const source of packageSources) {
     const base = source.replace(/\/$/, '');
     const candidates = [
+      `${base}/v2/${name}/latest.json`,
       `${base}/${platform}/${name}/latest.json`,
       `${base}/common/${name}/latest.json`,
     ];
@@ -84,12 +87,18 @@ async function resolveLatestVersion(name, packageSources, platform, httpClient)
         const response = await httpClient(url);
         if (!response.ok) continue;
         const data = await response.json();
-        if (data && data.version) return data.version;
+        if (data?.version) {
+          if (!best || compareVersions(data.version, best) > 0) {
+            best = data.version;
+          }
+        }
       } catch {
         // Try next candidate.
       }
     }
   }
+
+  if (best) return best;
   throw new Error(`Could not resolve "latest" version for "${name}" from any source`);
 }
 
@@ -229,8 +238,9 @@ async function resolveDependencies(rootDeps, packageSources, platform, httpClien
     }
 
     // Support both formats:
-    //   PascalCase array: { Dependencies: [ { Name, Version }, ... ] }
-    //   lowercase object: { dependencies: { name: version, ... } }
+    //   PascalCase array : { Dependencies: [ { Name, Version }, ... ] }
+    //   string object    : { dependencies: { name: "version", ... } }
+    //   object object    : { dependencies: { name: { version, settings }, ... } }
     let deps = [];
     if (Array.isArray(manifest.Dependencies)) {
       deps = manifest.Dependencies.filter((d) => d.Name && d.Version).map((d) => ({
@@ -238,10 +248,14 @@ async function resolveDependencies(rootDeps, packageSources, platform, httpClien
         version: d.Version,
       }));
     } else if (manifest.dependencies && typeof manifest.dependencies === 'object') {
-      deps = Object.entries(manifest.dependencies).map(([name, version]) => ({ name, version }));
+      deps = Object.entries(manifest.dependencies).map(([depName, depValue]) => ({
+        name: depName,
+        // Handle both "1.0.0" and { version: "1.0.0", settings: {...} }
+        version: typeof depValue === 'string' ? depValue : (depValue?.version ?? depValue?.Version ?? ''),
+      }));
     }
     for (const dep of deps) {
-      queue.push({ name: dep.name, version: dep.version });
+      if (dep.version) queue.push({ name: dep.name, version: dep.version });
     }
   }