@puzzmo/cli 1.0.32 → 1.0.34

package/src/util/api.ts

@@ -22,39 +22,49 @@ type CompleteResponse = { assetsBase: string; versionID: string; error?: string
 /** Callback for reporting batch upload progress */
 export type UploadProgress = (batch: number, totalBatches: number, uploaded: number) => void
 
+/** Options for uploadFiles */
+export type UploadFilesOptions = {
+  verbose?: boolean
+}
+
 /** Wraps fetch to surface the underlying network cause (DNS, ECONNREFUSED, TLS, etc.) */
-const fetchWithContext = async (url: string, init: RequestInit, step: string): Promise<Response> => {
+const fetchWithContext = async (url: string, init: RequestInit, step: string, verbose: boolean): Promise<Response> => {
+  if (verbose) console.log(`  → ${init.method ?? "GET"} ${url} [${step}]`)
   try {
-    return await fetch(url, init)
+    const res = await fetch(url, init)
+    if (verbose) console.log(`  ← ${res.status} ${res.statusText} [${step}]`)
+    return res
   } catch (e) {
     const cause = (e as { cause?: unknown }).cause
     const causeMsg = cause instanceof Error ? cause.message : cause ? String(cause) : (e as Error).message
+    if (verbose && e instanceof Error && e.stack) console.error(e.stack)
     throw new Error(`Network error during ${step} (${url}): ${causeMsg}`)
   }
 }
 
 /** Reads a response body, parsing JSON when possible and including status + body in errors */
-const readResponse = async (res: Response, url: string, step: string) => {
+const readResponse = async (res: Response, url: string, step: string, verbose: boolean) => {
   const text = await res.text()
   let json: unknown
   try {
     json = text ? JSON.parse(text) : {}
   } catch {
     if (!res.ok) {
-      const snippet = text.slice(0, 200).replace(/\s+/g, " ").trim()
+      const snippet = verbose ? text : text.slice(0, 200).replace(/\s+/g, " ").trim()
       throw new Error(`Server error during ${step} (${res.status} ${res.statusText} from ${url}): ${snippet || "no body"}`)
     }
-    throw new Error(`Invalid JSON response during ${step} (${url}): ${text.slice(0, 200)}`)
+    throw new Error(`Invalid JSON response during ${step} (${url}): ${verbose ? text : text.slice(0, 200)}`)
   }
   if (!res.ok) {
     const serverMsg = (json as { error?: string }).error || res.statusText || "Unknown error"
-    throw new Error(`Server error during ${step} (${res.status} from ${url}): ${serverMsg}`)
+    const detail = verbose ? `\n${JSON.stringify(json, null, 2)}` : ""
+    throw new Error(`Server error during ${step} (${res.status} from ${url}): ${serverMsg}${detail}`)
   }
   return json
 }
 
 /** Sends a JSON POST request */
-const jsonPost = async (url: string, token: string, body: object, step: string) => {
+const jsonPost = async (url: string, token: string, body: object, step: string, verbose: boolean) => {
   const res = await fetchWithContext(
     url,
     {
@@ -63,12 +73,13 @@ const jsonPost = async (url: string, token: string, body: object, step: string)
       body: JSON.stringify(body),
     },
     step,
+    verbose,
   )
-  return readResponse(res, url, step)
+  return readResponse(res, url, step, verbose)
 }
 
 /** Uploads a single file as raw binary with filename in query param */
-const uploadFile = async (url: string, token: string, filePath: string, baseDir: string): Promise<FileResponse> => {
+const uploadFile = async (url: string, token: string, filePath: string, baseDir: string, verbose: boolean): Promise<FileResponse> => {
   const relativePath = path.relative(baseDir, filePath)
   const content = fs.readFileSync(filePath)
   const step = `file upload (${relativePath})`
@@ -85,8 +96,9 @@ const uploadFile = async (url: string, token: string, filePath: string, baseDir:
       body: content,
     },
     step,
+    verbose,
   )
-  return (await readResponse(res, fullURL, step)) as FileResponse
+  return (await readResponse(res, fullURL, step, verbose)) as FileResponse
 }
 
 /** Multi-step upload: init -> batched file uploads -> complete */
@@ -98,11 +110,15 @@ export const uploadFiles = async (
   baseDir: string,
   puzzmoFile: PuzzmoFile,
   onProgress?: UploadProgress,
+  options: UploadFilesOptions = {},
 ): Promise<CompleteResponse> => {
+  const { verbose = false } = options
   const apiURL = getAPIURL()
+  if (verbose) console.log(`  API URL: ${apiURL}`)
 
   // Step 1: Init session (includes puzzmo.json metadata)
-  const init = (await jsonPost(`${apiURL}/cliUpload`, token, { gameSlug, sha, puzzmoFile }, "upload init")) as InitResponse
+  const init = (await jsonPost(`${apiURL}/cliUpload`, token, { gameSlug, sha, puzzmoFile }, "upload init", verbose)) as InitResponse
+  if (verbose) console.log(`  session: ${init.sessionID}`)
 
   // Step 2: Upload files in concurrent batches
   const fileURL = `${apiURL}/cliUpload/${init.sessionID}/file`
@@ -112,11 +128,11 @@ export const uploadFiles = async (
   for (let i = 0; i < filePaths.length; i += BATCH_SIZE) {
     const batch = filePaths.slice(i, i + BATCH_SIZE)
     const batchNum = Math.floor(i / BATCH_SIZE) + 1
-    await Promise.all(batch.map((fp) => uploadFile(fileURL, token, fp, baseDir)))
+    await Promise.all(batch.map((fp) => uploadFile(fileURL, token, fp, baseDir, verbose)))
     totalUploaded += batch.length
     onProgress?.(batchNum, totalBatches, totalUploaded)
   }
 
   // Step 3: Complete
-  return (await jsonPost(`${apiURL}/cliUpload/${init.sessionID}/complete`, token, {}, "upload complete")) as CompleteResponse
+  return (await jsonPost(`${apiURL}/cliUpload/${init.sessionID}/complete`, token, {}, "upload complete", verbose)) as CompleteResponse
 }

package/src/util/validatePuzzmoFile.ts

@@ -1,18 +1,32 @@
-import { Validator } from "@cfworker/json-schema"
+import { Validator, type Schema } from "@cfworker/json-schema"
 
 import type { PuzzmoFile } from "./api.js"
 
-const schemaURL = "https://dev.puzzmo.com/schema/puzzmo-file-schema.json"
+const schemaURL = "https://dev-dj9e.onrender.com/schema/puzzmo-file-schema.json" //"https://dev.puzzmo.com/schema/puzzmo-file-schema.json"
 
 let cachedValidator: Validator | undefined
 
 /** Fetches and caches a JSON schema validator for puzzmo.json files */
 const getValidator = async () => {
   if (cachedValidator) return cachedValidator
-  const res = await fetch(schemaURL)
-  if (!res.ok) throw new Error(`Failed to fetch puzzmo file schema: ${res.status}`)
-  const puzzmoSchema = await res.json()
-  cachedValidator = new Validator(puzzmoSchema, "7")
+  let res: Response
+  try {
+    res = await fetch(schemaURL)
+  } catch (e) {
+    const cause = (e as { cause?: unknown }).cause
+    const causeMsg = cause instanceof Error ? cause.message : cause ? String(cause) : (e as Error).message
+    throw new Error(`Network error fetching puzzmo file schema (${schemaURL}): ${causeMsg}`)
+  }
+  if (!res.ok) {
+    throw new Error(`Failed to fetch puzzmo file schema: ${res.status} ${res.statusText} from ${schemaURL}`)
+  }
+  let puzzmoSchema: unknown
+  try {
+    puzzmoSchema = await res.json()
+  } catch (e) {
+    throw new Error(`Invalid JSON in puzzmo file schema (${schemaURL}): ${e instanceof Error ? e.message : e}`)
+  }
+  cachedValidator = new Validator(puzzmoSchema as Schema, "7")
   return cachedValidator
 }
 
@@ -21,7 +35,8 @@ type ValidationResult = { valid: true; data: PuzzmoFile } | { valid: false; erro
 /** Validates a parsed object against the puzzmo.json JSON schema */
 export const validatePuzzmoJson = async (data: unknown): Promise<ValidationResult> => {
   const validator = await getValidator()
-  const result = validator.validate(data)
+  const toValidate = stripSchemaProperty(data)
+  const result = validator.validate(toValidate)
   if (result.valid) return { valid: true, data: data as PuzzmoFile }
   return {
     valid: false,
@@ -30,3 +45,11 @@ export const validatePuzzmoJson = async (data: unknown): Promise<ValidationResul
       .map((e) => `${e.instanceLocation}: ${e.error}`),
   }
 }
+
+/** Removes the `$schema` editor-hint property so it doesn't trip additionalProperties checks */
+const stripSchemaProperty = (data: unknown): unknown => {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return data
+  if (!("$schema" in data)) return data
+  const { $schema: _, ...rest } = data as Record<string, unknown>
+  return rest
+}