@knolo/cli 5.2.2 → 5.2.3

package/README.md

@@ -57,28 +57,23 @@ knolo login --token kno_…
 # write requests use: Authorization: Bearer kno_…
 ```
 
-`knolo publish` uploads bytes with `@vercel/blob` to the public store, waits
-for verification, creates an attested draft, and releases it. Set
-`PACKS_READ_WRITE_TOKEN` from the production `knolo-hub` Vercel environment
-before publishing; do not substitute `BLOB_READ_WRITE_TOKEN`:
+`knolo publish` asks Hub for a Blob PUT grant with the dashboard token, PUTs
+bytes to that grant URL, then completes with the public pack URL from the PUT
+response. A `kno_…` token is the only credential. Do not set
+`PACKS_READ_WRITE_TOKEN` — that is Hub’s store secret, not a publisher token.
 
 ```bash
-cd /path/to/knolo-hub
-npx vercel env pull /tmp/knolo-env-prod --environment=production --yes
-export PACKS_READ_WRITE_TOKEN="$(awk -F= '$1 == "PACKS_READ_WRITE_TOKEN" {sub(/^[^=]*=/, ""); gsub(/^\"|\"$/, ""); print; exit}' /tmp/knolo-env-prod)"
-
+knolo login --token kno_…
 knolo publish ./dist/knowledge.knolo \
   --slug refund-policy --version 1.2.0 --license Apache-2.0
 knolo yank acme/refund-policy@1.2.0
 ```
 
-The upload uses pathname `sha256/<64-lowercase-hex>.knolo`, public access,
-`addRandomSuffix: false`, `application/octet-stream`, and a one-year cache.
-Only public Blob URLs are accepted because Hub verification fetches the
-artifact itself. The CLI never sends the `kno_…` token to Blob, in a query
-string, cookie, or pack bytes. A 401 usually means the `Bearer` word is
-missing or the token was revoked; it does not mean the Hub write API requires
-a GitHub browser session.
+The grant pathname is `sha256/<64-lowercase-hex>.knolo`. Only public Blob URLs
+(`*.public.blob.vercel-storage.com`) are sent to `/api/upload/complete`. The
+CLI never sends the `kno_…` token to Blob, in a query string, cookie, or pack
+bytes. A 401 usually means the `Bearer` word is missing or the token was
+revoked; it does not mean the Hub write API requires a GitHub browser session.
 
 The older `@knolo/cli@5.2.0` publish/yank command was an unimplemented stub;
 current versions use the live Hub HTTP sequence. For a direct smoke test of a

package/bin/knolo.mjs

@@ -115,7 +115,7 @@ function printCommandHelp(command) {
     login: 'Usage: knolo login [--token kno_…] [--stdin] [--registry <url>]\n\nStores the raw token locally. Hub write calls send Authorization: Bearer kno_….\nMint tokens at https://hub.knolo.dev/dashboard/tokens; login does not call POST /api/v1/tokens.',
     whoami: 'Usage: knolo whoami',
     logout: 'Usage: knolo logout',
-    publish: 'Usage: knolo publish <pack.knolo> --slug <slug> --version <version> --license <SPDX> [--publisher <handle>] [--readme <text>] [--sources <text>] [--intended-use <text>] [--json] [--registry <url>]\n\nUses the stored token as Authorization: Bearer kno_…. Uploads go directly to a public Blob URL; Hub verifies before release.\nOlder @knolo/cli 5.2.0 builds were unimplemented; Hub has always accepted Bearer CLI tokens.',
+    publish: 'Usage: knolo publish <pack.knolo> --slug <slug> --version <version> --license <SPDX> [--publisher <handle>] [--readme <text>] [--sources <text>] [--intended-use <text>] [--json] [--registry <url>]\n\nUses the stored dashboard token as Authorization: Bearer kno_…. Hub issues a public Blob PUT grant; the CLI never needs PACKS_READ_WRITE_TOKEN.\nUploads go to the grant URL without the kno_ token. Complete sends the public Blob URL, then Hub verifies before release.',
     yank: 'Usage: knolo yank <publisher>/<slug>@<version> [--json] [--registry <url>]\n\nUses the stored token as Authorization: Bearer kno_…. Yank is owner-only and leaves the public Blob in place.',
     build: 'Usage: knolo build',
     query: 'Usage: knolo query <question> [--pack <path>] [--k <number>] [--receipt <file>] [--json]',

package/bin/registry/commands.mjs

@@ -11,7 +11,6 @@ import { createHash, randomUUID } from 'node:crypto';
 import { isIP } from 'node:net';
 import { homedir } from 'node:os';
 import path from 'node:path';
-import { put as putBlob } from '@vercel/blob';
 import {
   normalizeRegistryUrl,
   registryApiUrl,
@@ -24,7 +23,7 @@ import {
   stageCachedArtifact,
 } from './artifacts.mjs';
 import { RegistryError } from './errors.mjs';
-import { getJson, postJson } from './http.mjs';
+import { getJson, postJson, putBytes } from './http.mjs';
 import {
   cachePath,
   stageLockfileUpdate,
@@ -291,7 +290,6 @@ export async function runHubPublish(
     homeDir,
     print = console.log,
     sleep = wait,
-    putImpl = putBlob,
     pollIntervalMs = 1000,
     maxPollAttempts = 120,
   } = {}
@@ -329,28 +327,35 @@ export async function runHubPublish(
   const sha256 = createSha256(bytes);
   const pathname = `sha256/${sha256}.knolo`;
 
-  const uploaded = await putImpl(pathname, bytes, {
-    access: 'public',
-    addRandomSuffix: false,
-    // The pathname is content-addressed by the already-computed SHA-256.
-    // Allowing overwrite makes a retry safe after a partial Hub publish.
-    allowOverwrite: true,
-    contentType: 'application/octet-stream',
-    cacheControlMaxAge: 31536000,
-    token: packsReadWriteToken(env),
-  });
-  if (!uploaded || typeof uploaded.url !== 'string' || !uploaded.url) {
-    throw new Error('Public Blob upload did not return a URL.');
-  }
-  if (uploaded.pathname !== undefined && uploaded.pathname !== pathname) {
-    throw new Error(
-      `Public Blob upload pathname is not locked to ${pathname}.`
-    );
+  const grant = await postJson(
+    hubApiUrl(registry, ['upload', 'token']),
+    { sha256, contentLength: bytes.length },
+    { fetchImpl, headers: authHeaders }
+  );
+  const upload = resolveUploadGrant(grant, sha256);
+  let blobUrl;
+  if (upload.reused) {
+    blobUrl = assertPublicPackBlobUrl(upload.url, 'reused artifact').toString();
+  } else {
+    assertGrantPutUrl(upload.putUrl, 'upload grant');
+    const uploaded = await putBytes(upload.putUrl, bytes, {
+      fetchImpl,
+      headers: {
+        'content-type': 'application/octet-stream',
+        ...(upload.putHeaders || {}),
+        'content-length': String(bytes.length),
+      },
+    });
+    if (uploaded.pathname !== undefined && uploaded.pathname !== pathname) {
+      throw new Error(
+        `Public Blob upload pathname is not locked to ${pathname}.`
+      );
+    }
+    blobUrl = assertPublicPackBlobUrl(
+      uploaded.url,
+      'uploaded artifact'
+    ).toString();
   }
-  const blobUrl = assertPublicBlobUrl(
-    uploaded.url,
-    'uploaded artifact'
-  ).toString();
 
   await postJson(
     hubApiUrl(registry, ['upload', 'complete']),
@@ -593,16 +598,59 @@ function createSha256(bytes) {
   return createHash('sha256').update(bytes).digest('hex');
 }
 
-function packsReadWriteToken(env) {
-  const token =
-    typeof env?.PACKS_READ_WRITE_TOKEN === 'string'
-      ? env.PACKS_READ_WRITE_TOKEN.trim()
-      : '';
-  if (!token)
+function resolveUploadGrant(body, sha256) {
+  const pathname = body?.pathname || body?.upload?.pathname;
+  const expectedPathname = `sha256/${sha256}.knolo`;
+  if (typeof pathname !== 'string' || pathname !== expectedPathname) {
+    throw new Error(`Hub upload pathname is not locked to ${expectedPathname}.`);
+  }
+
+  const reusedUrl =
+    (body?.reused && (body?.artifact?.url || body?.url)) ||
+    body?.artifact?.url;
+  if (typeof reusedUrl === 'string' && reusedUrl) {
+    return { reused: true, pathname, url: reusedUrl };
+  }
+
+  const upload = body?.upload && typeof body.upload === 'object' ? body.upload : body;
+  if (!upload || typeof upload.url !== 'string' || !upload.url) {
+    if (body?.clientToken || upload?.clientToken) {
+      throw new Error(
+        'Hub returned a Blob client token without upload.url. This CLI PUTs to upload.url; it does not use PACKS_READ_WRITE_TOKEN.'
+      );
+    }
+    throw new Error('Hub upload token response is missing upload.url.');
+  }
+  return {
+    reused: false,
+    pathname,
+    putUrl: upload.url,
+    putHeaders:
+      upload.headers && typeof upload.headers === 'object' ? upload.headers : {},
+  };
+}
+
+function assertGrantPutUrl(value, label) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`Hub ${label} URL is invalid.`);
+  }
+  if (url.protocol !== 'https:')
+    throw new Error(`Hub ${label} URL must use HTTPS.`);
+  const hostname = url.hostname.toLowerCase();
+  if (
+    hostname.includes('.private.') ||
+    hostname.startsWith('private.') ||
+    isPrivateOrLocalIp(hostname) ||
+    isLocalOnlyHostname(hostname)
+  ) {
     throw new Error(
-      'PACKS_READ_WRITE_TOKEN is required for public Blob uploads.'
+      `Refusing private Blob URL for ${label}; Hub verification requires a public Blob URL.`
     );
-  return token;
+  }
+  return url;
 }
 
 function extractPublisherHandle(account) {
@@ -611,8 +659,10 @@ function extractPublisherHandle(account) {
     account?.publisher?.handle,
     account?.publisher?.slug,
     account?.handle,
+    account?.account?.handle,
     account?.account?.publisherHandle,
     account?.account?.publisher?.handle,
+    account?.user?.handle,
     account?.user?.publisherHandle,
     account?.publishers?.[0]?.handle,
     account?.publishers?.[0]?.slug,
@@ -655,6 +705,20 @@ function assertPublicBlobUrl(value, label) {
   return url;
 }
 
+function assertPublicPackBlobUrl(value, label) {
+  const url = assertPublicBlobUrl(value, label);
+  const hostname = url.hostname.toLowerCase();
+  const blobHost =
+    hostname === 'blob.vercel-storage.com' ||
+    hostname.endsWith('.blob.vercel-storage.com');
+  if (!blobHost || hostname.includes('.private.')) {
+    throw new Error(
+      `Hub ${label} URL must be a public Vercel Blob pack URL (not a signed grant URL).`
+    );
+  }
+  return url;
+}
+
 function isLocalOnlyHostname(hostname) {
   const normalized = hostname.replace(/^\[|\]$/g, '').replace(/\.$/, '');
   return (

package/bin/registry/http.mjs

@@ -19,6 +19,67 @@ export async function postJson(
   return requestJson(url, { fetchImpl, headers, method: 'POST', body });
 }
 
+export async function putBytes(
+  url,
+  bytes,
+  { fetchImpl = globalThis.fetch, headers = {} } = {}
+) {
+  if (typeof fetchImpl !== 'function')
+    throw new Error('This Node runtime does not provide fetch.');
+
+  let response;
+  try {
+    response = await fetchImpl(url, {
+      method: 'PUT',
+      redirect: 'follow',
+      headers: { 'content-type': 'application/octet-stream', ...headers },
+      body: bytes,
+    });
+  } catch (error) {
+    throw new RegistryNetworkError(
+      `Could not upload artifact to ${new URL(url).origin}.`,
+      { url: String(url), cause: error }
+    );
+  }
+
+  const text = await readResponseText(response, url);
+  let parsed;
+  if (text) {
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      parsed = undefined;
+    }
+  }
+
+  if (!response.ok) {
+    const detail =
+      (parsed && typeof parsed.error === 'object' && parsed.error?.message) ||
+      (typeof parsed?.error === 'string' && parsed.error) ||
+      (typeof parsed?.message === 'string' && parsed.message) ||
+      (text ? text.slice(0, 240) : '');
+    throw new RegistryError(
+      `Blob upload failed with HTTP ${response.status}${detail ? `: ${detail}` : '.'}`,
+      {
+        status: response.status,
+        url: String(url),
+        body: parsed ?? text,
+      }
+    );
+  }
+
+  const publicUrl =
+    (parsed && typeof parsed.url === 'string' && parsed.url) ||
+    response.url ||
+    String(url);
+  return {
+    status: response.status,
+    url: publicUrl,
+    pathname: parsed && typeof parsed.pathname === 'string' ? parsed.pathname : undefined,
+    body: parsed,
+  };
+}
+
 async function requestJson(
   url,
   {

package/package.json

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