@knolo/cli 5.2.0 → 5.2.2

package/bin/registry/errors.mjs

@@ -18,8 +18,10 @@ export class RegistryNetworkError extends Error {
 }
 
 export function registryErrorMessage({ status, code, body, url }) {
+  if (status === 401 || code === 'unauthenticated') {
+    return 'Hub authentication failed. Use Authorization: Bearer kno_…; a revoked token can also return 401. GitHub sign-in is only required to mint tokens.';
+  }
   if (typeof body?.error === 'string' && body.error.trim()) return body.error.trim();
-  if (status === 401 || code === 'unauthenticated') return 'Registry authentication is required.';
   if (status === 404 || code === 'not_found') return 'Registry resource not found.';
   if (status === 410 || code === 'yanked') return 'Registry version is yanked.';
   if (status === 413 || code === 'too_large') return 'Registry artifact is too large.';

package/bin/registry/http.mjs

@@ -1,17 +1,57 @@
-import { RegistryError, RegistryNetworkError, registryErrorMessage } from './errors.mjs';
+import {
+  RegistryError,
+  RegistryNetworkError,
+  registryErrorMessage,
+} from './errors.mjs';
 
-export async function getJson(url, { fetchImpl = globalThis.fetch, headers = {} } = {}) {
-  if (typeof fetchImpl !== 'function') throw new Error('This Node runtime does not provide fetch.');
+export async function getJson(
+  url,
+  { fetchImpl = globalThis.fetch, headers = {} } = {}
+) {
+  return requestJson(url, { fetchImpl, headers, method: 'GET' });
+}
+
+export async function postJson(
+  url,
+  body,
+  { fetchImpl = globalThis.fetch, headers = {} } = {}
+) {
+  return requestJson(url, { fetchImpl, headers, method: 'POST', body });
+}
+
+async function requestJson(
+  url,
+  {
+    fetchImpl = globalThis.fetch,
+    headers = {},
+    method = 'GET',
+    body: requestBody,
+  } = {}
+) {
+  if (typeof fetchImpl !== 'function')
+    throw new Error('This Node runtime does not provide fetch.');
 
   let response;
   try {
     response = await fetchImpl(url, {
-      method: 'GET',
+      method,
       redirect: 'follow',
-      headers: { accept: 'application/json', ...headers },
+      headers: {
+        accept: 'application/json',
+        ...(requestBody !== undefined
+          ? { 'content-type': 'application/json' }
+          : {}),
+        ...headers,
+      },
+      ...(requestBody !== undefined
+        ? { body: JSON.stringify(requestBody) }
+        : {}),
     });
   } catch (error) {
-    throw new RegistryNetworkError(`Could not reach registry at ${new URL(url).origin}.`, { url: String(url), cause: error });
+    throw new RegistryNetworkError(
+      `Could not reach registry at ${new URL(url).origin}.`,
+      { url: String(url), cause: error }
+    );
   }
 
   const text = await readResponseText(response, url);
@@ -21,11 +61,14 @@ export async function getJson(url, { fetchImpl = globalThis.fetch, headers = {}
       body = JSON.parse(text);
     } catch {
       if (!response.ok) {
-        throw new RegistryError(`Registry returned HTTP ${response.status} with a non-JSON response.`, {
-          status: response.status,
-          url: String(url),
-          body: text.slice(0, 240),
-        });
+        throw new RegistryError(
+          `Registry returned HTTP ${response.status} with a non-JSON response.`,
+          {
+            status: response.status,
+            url: String(url),
+            body: text.slice(0, 240),
+          }
+        );
       }
       throw new RegistryError('Registry returned invalid JSON.', {
         status: response.status,
@@ -38,12 +81,20 @@ export async function getJson(url, { fetchImpl = globalThis.fetch, headers = {}
 
   if (!response.ok) {
     const code = typeof body?.code === 'string' ? body.code : undefined;
-    throw new RegistryError(registryErrorMessage({ status: response.status, code, body, url: String(url) }), {
-      status: response.status,
-      code,
-      url: String(url),
-      body,
-    });
+    throw new RegistryError(
+      registryErrorMessage({
+        status: response.status,
+        code,
+        body,
+        url: String(url),
+      }),
+      {
+        status: response.status,
+        code,
+        url: String(url),
+        body,
+      }
+    );
   }
 
   return body;
@@ -53,6 +104,9 @@ async function readResponseText(response, url) {
   try {
     return await response.text();
   } catch (error) {
-    throw new RegistryNetworkError(`Could not read registry response from ${new URL(url).origin}.`, { url: String(url), cause: error });
+    throw new RegistryNetworkError(
+      `Could not read registry response from ${new URL(url).origin}.`,
+      { url: String(url), cause: error }
+    );
   }
 }

package/bin/registry/lockfile.mjs

@@ -37,13 +37,23 @@ export async function validateLockfileUpdate({ cwd = process.cwd(), registry, ma
 }
 
 export async function upsertLockfile({ cwd = process.cwd(), registry, manifest, force = false } = {}) {
+  const staged = await stageLockfileUpdate({ cwd, registry, manifest, force });
+  try {
+    await rename(staged.tempPath, staged.path);
+  } finally {
+    await unlink(staged.tempPath).catch(() => {});
+  }
+  return { path: staged.path, entry: staged.entry };
+}
+
+export async function stageLockfileUpdate({ cwd = process.cwd(), registry, manifest, force = false } = {}) {
   const { targetPath, entry, packs } = await validateLockfileUpdate({ cwd, registry, manifest, force });
   const next = {
     registry,
     packs: { ...packs, [manifest.name]: entry },
   };
-  await atomicWriteJson(targetPath, next);
-  return { path: targetPath, entry };
+  const tempPath = await writeJsonTemp(targetPath, next);
+  return { path: targetPath, tempPath, entry };
 }
 
 async function readLockfile(filePath) {
@@ -66,13 +76,14 @@ async function readLockfile(filePath) {
   return value;
 }
 
-async function atomicWriteJson(filePath, value) {
+async function writeJsonTemp(filePath, value) {
   await mkdir(path.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.tmp-${process.pid}-${randomUUID()}`;
   try {
     await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o644 });
-    await rename(tempPath, filePath);
-  } finally {
+    return tempPath;
+  } catch (error) {
     await unlink(tempPath).catch(() => {});
+    throw error;
   }
 }

package/bin/registry/manifest.mjs

@@ -20,6 +20,12 @@ export function validatePackManifest(value, { expectedName, requestedVersion } =
   if (value.stateRoot !== undefined && typeof value.stateRoot !== 'string') {
     throw new Error('Registry manifest stateRoot must be a string when present.');
   }
+  if (value.format !== undefined && !['V4', 'V5'].includes(value.format)) {
+    throw new Error('Registry manifest format must be V4 or V5 when present.');
+  }
+  if (value.format === 'V5' && (!value.stateRoot || typeof value.stateRoot !== 'string')) {
+    throw new Error('Registry manifest stateRoot is required for V5 manifests.');
+  }
   if (value.license !== undefined && typeof value.license !== 'string') {
     throw new Error('Registry manifest license must be a string when present.');
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knolo/cli",
-  "version": "5.2.0",
+  "version": "5.2.2",
   "type": "module",
   "bin": {
     "knolo": "bin/knolo.mjs"
@@ -32,7 +32,8 @@
     "test:hub": "node --test test/hub.integration.test.mjs"
   },
   "dependencies": {
-    "@knolo/core": "^5.1.0"
+    "@knolo/core": "^5.1.0",
+    "@vercel/blob": "2.8.0"
   },
   "private": false
 }