@clickraft/cli 0.8.6 → 0.8.8

package/CHANGELOG.md

@@ -1,4 +1,4 @@
-## [0.8.6](https://github.com/clickraft/cli/compare/v0.8.5...v0.8.6) (2026-05-31)
+## [0.8.8](https://github.com/clickraft/cli/compare/v0.8.7...v0.8.8) (2026-05-31)
 
 # Changelog
 

package/dist/cli.js

@@ -14,6 +14,8 @@ import { request as undiciRequest } from "undici";
 import { z as z6 } from "zod";
 import { createHash, randomUUID } from "crypto";
 import { z as z5 } from "zod";
+import { createHash as createHash2 } from "crypto";
+import { request as undiciRequest2 } from "undici";
 var TOKEN_FIELD_PATTERN = /"(access_token|refresh_token|device_code|user_code|code_verifier|client_secret)"\s*:\s*"[^"]*"/gi;
 var BARE_TOKEN_PATTERN = /\bck_(?:live|dev|test)_[A-Za-z0-9_-]+/gi;
 function redactTokenLikeFields(input) {
@@ -677,6 +679,178 @@ async function patch(params) {
     workflow: data.workflow
   };
 }
+async function uploadAsset(params) {
+  const contentType = detectContentType(params.filename, params.content);
+  const sha = sha256Hex(params.content);
+  const contentHash = `sha256:${sha}`;
+  const idempotencyKey = generateUploadIdempotencyKey(params.content, params.scope);
+  const response = await params.client.request({
+    method: "POST",
+    path: "/assets",
+    body: {
+      filename: params.filename,
+      contentType,
+      sizeBytes: params.content.length,
+      contentHash
+    },
+    idempotencyKey,
+    responseSchema: params.schema,
+    signal: params.signal
+  });
+  if (!response.deduplicated) {
+    const first = await tryPut({
+      uploadUrl: response.uploadUrl,
+      content: params.content,
+      contentType,
+      signal: params.signal,
+      dispatcher: params.putDispatcher
+    });
+    if (!first.ok) {
+      if (first.kind === "fatal") {
+        throw new ApiError(
+          "STORAGE_UPLOAD_FAILED",
+          `Upload to signed URL failed for ${params.filename} (HTTP ${first.status ?? "unknown"}).`,
+          { retryable: false }
+        );
+      }
+      const retry = await tryPut({
+        uploadUrl: response.uploadUrl,
+        content: params.content,
+        contentType,
+        signal: params.signal,
+        dispatcher: params.putDispatcher
+      });
+      if (!retry.ok) {
+        throw new ApiError(
+          "STORAGE_UPLOAD_FAILED",
+          `Upload to signed URL failed for ${params.filename} after one retry.`,
+          { retryable: true }
+        );
+      }
+    }
+  }
+  return {
+    assetId: response.assetId,
+    publicUrl: response.publicUrl,
+    deduplicated: response.deduplicated,
+    bytes: params.content.length,
+    contentHash
+  };
+}
+async function tryPut(args) {
+  try {
+    const response = await undiciRequest2(args.uploadUrl, {
+      method: "PUT",
+      body: args.content,
+      headers: {
+        "content-type": args.contentType,
+        "content-length": String(args.content.length)
+      },
+      signal: args.signal,
+      dispatcher: args.dispatcher
+    });
+    await response.body.text();
+    const status = response.statusCode;
+    if (status >= 200 && status < 300) return { ok: true };
+    if (status >= 400 && status < 500) return { ok: false, kind: "fatal", status };
+    return { ok: false, kind: "retryable", status };
+  } catch {
+    return { ok: false, kind: "retryable" };
+  }
+}
+function sha256Hex(content) {
+  return createHash2("sha256").update(content).digest("hex");
+}
+var MAGIC_NUMBERS = [
+  { contentType: "image/png", prefix: [137, 80, 78, 71, 13, 10, 26, 10] },
+  { contentType: "image/jpeg", prefix: [255, 216, 255] },
+  { contentType: "image/webp", prefix: [82, 73, 70, 70] }
+  // also matches WAV — disambiguated below
+];
+var EXTENSION_FALLBACK = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  pdf: "application/pdf",
+  txt: "text/plain",
+  json: "application/json"
+};
+function detectContentType(filename, content) {
+  if (content.length >= 6) {
+    const head = content.subarray(0, 6).toString("ascii");
+    if (head === "GIF87a" || head === "GIF89a") return "image/gif";
+  }
+  if (content.length >= 12 && content.subarray(4, 8).toString("ascii") === "ftyp") {
+    return "video/mp4";
+  }
+  for (const { contentType, prefix } of MAGIC_NUMBERS) {
+    if (matchesPrefix(content, prefix)) {
+      if (contentType === "image/webp") {
+        const formatId = content.subarray(8, 12).toString("ascii");
+        if (formatId === "WEBP") return "image/webp";
+        if (formatId === "WAVE") return "audio/wav";
+        break;
+      }
+      return contentType;
+    }
+  }
+  const ext = filename.toLowerCase().split(".").pop();
+  if (ext && EXTENSION_FALLBACK[ext]) {
+    return EXTENSION_FALLBACK[ext];
+  }
+  return "application/octet-stream";
+}
+function matchesPrefix(content, prefix) {
+  if (content.length < prefix.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (content[i] !== prefix[i]) return false;
+  }
+  return true;
+}
+function waitForGeneration(params) {
+  return longPoll({
+    // Forward the iteration signal so the in-flight server hold is aborted as
+    // soon as the overall deadline expires — otherwise `--timeout 1` would still
+    // block for the full server long-poll round.
+    fetcher: (args) => params.client.request({
+      method: "GET",
+      path: `/jobs/${encodeURIComponent(params.jobId)}`,
+      query: { wait: params.serverWaitSeconds },
+      responseSchema: params.resultSchema,
+      signal: args?.signal
+    }),
+    isTerminal: params.isTerminal,
+    timeoutMs: params.timeoutMs,
+    signal: params.signal
+  });
+}
+async function createGeneration(params) {
+  const created = await params.client.request({
+    method: "POST",
+    path: "/jobs",
+    body: params.body,
+    responseSchema: params.createSchema,
+    signal: params.signal
+  });
+  if (!params.wait) {
+    return params.projectCreated(created, params.modelSlug);
+  }
+  return waitForGeneration({
+    client: params.client,
+    jobId: created.jobId,
+    timeoutMs: params.timeoutMs,
+    serverWaitSeconds: params.serverWaitSeconds,
+    signal: params.signal,
+    resultSchema: params.resultSchema,
+    isTerminal: params.isTerminal
+  });
+}
 
 // src/errors/codes.ts
 var LOGIN_HINT = "Run `clickraft login` to authenticate.";
@@ -1635,10 +1809,9 @@ var GenerationResultSchema = z9.object({
 }).strict();
 
 // src/commands/upload.ts
-import { createHash as createHash2 } from "crypto";
 import { readFile as readFile2, stat as stat2 } from "fs/promises";
 import { basename } from "path";
-import { request as undiciRequest2 } from "undici";
+import "undici";
 
 // src/schemas/assets.ts
 import { z as z10 } from "zod";
@@ -1663,60 +1836,16 @@ async function uploadFile(opts) {
   const size = await safeStatSize(opts.filePath);
   validateSize(size);
   const content = await safeReadFile(opts.filePath);
-  const contentType = detectContentType(opts.filePath, content);
-  const sha = sha256Hex(content);
-  const contentHash = `sha256:${sha}`;
-  const filename = basename(opts.filePath);
-  const idempotencyKey = generateUploadIdempotencyKey(content, scope);
   const client = opts.client ?? await buildClient(opts);
-  const response = await postAssetMetadata({
+  return uploadAsset({
     client,
-    filename,
-    contentType,
-    sizeBytes: content.length,
-    contentHash,
-    idempotencyKey,
-    signal: opts.signal
+    content,
+    filename: basename(opts.filePath),
+    scope,
+    signal: opts.signal,
+    putDispatcher: opts.putDispatcher,
+    schema: UploadResponseSchema
   });
-  if (!response.deduplicated) {
-    const first = await tryPut({
-      uploadUrl: response.uploadUrl,
-      content,
-      contentType,
-      signal: opts.signal,
-      dispatcher: opts.putDispatcher
-    });
-    if (!first.ok) {
-      if (first.kind === "fatal") {
-        throw new ApiError(
-          "STORAGE_UPLOAD_FAILED",
-          `Upload to signed URL failed for ${filename} (HTTP ${first.status ?? "unknown"}).`,
-          { retryable: false }
-        );
-      }
-      const retry = await tryPut({
-        uploadUrl: response.uploadUrl,
-        content,
-        contentType,
-        signal: opts.signal,
-        dispatcher: opts.putDispatcher
-      });
-      if (!retry.ok) {
-        throw new ApiError(
-          "STORAGE_UPLOAD_FAILED",
-          `Upload to signed URL failed for ${filename} after one retry.`,
-          { retryable: true }
-        );
-      }
-    }
-  }
-  return {
-    assetId: response.assetId,
-    publicUrl: response.publicUrl,
-    deduplicated: response.deduplicated,
-    bytes: content.length,
-    contentHash
-  };
 }
 async function buildClient(opts) {
   const cfg = await loadConfig({
@@ -1731,42 +1860,6 @@ async function buildClient(opts) {
     cloudflareAccess: cfg.cloudflareAccess
   });
 }
-async function postAssetMetadata(args) {
-  return args.client.request({
-    method: "POST",
-    path: "/assets",
-    body: {
-      filename: args.filename,
-      contentType: args.contentType,
-      sizeBytes: args.sizeBytes,
-      contentHash: args.contentHash
-    },
-    idempotencyKey: args.idempotencyKey,
-    responseSchema: UploadResponseSchema,
-    signal: args.signal
-  });
-}
-async function tryPut(args) {
-  try {
-    const response = await undiciRequest2(args.uploadUrl, {
-      method: "PUT",
-      body: args.content,
-      headers: {
-        "content-type": args.contentType,
-        "content-length": String(args.content.length)
-      },
-      signal: args.signal,
-      dispatcher: args.dispatcher
-    });
-    await response.body.text();
-    const status = response.statusCode;
-    if (status >= 200 && status < 300) return { ok: true };
-    if (status >= 400 && status < 500) return { ok: false, kind: "fatal", status };
-    return { ok: false, kind: "retryable", status };
-  } catch {
-    return { ok: false, kind: "retryable" };
-  }
-}
 async function safeStatSize(filePath) {
   let stats;
   try {
@@ -1828,61 +1921,6 @@ function validateSize(bytes) {
     );
   }
 }
-function sha256Hex(content) {
-  return createHash2("sha256").update(content).digest("hex");
-}
-var MAGIC_NUMBERS = [
-  { contentType: "image/png", prefix: [137, 80, 78, 71, 13, 10, 26, 10] },
-  { contentType: "image/jpeg", prefix: [255, 216, 255] },
-  { contentType: "image/webp", prefix: [82, 73, 70, 70] }
-  // also matches WAV — disambiguated below
-];
-var EXTENSION_FALLBACK = {
-  png: "image/png",
-  jpg: "image/jpeg",
-  jpeg: "image/jpeg",
-  gif: "image/gif",
-  webp: "image/webp",
-  mp4: "video/mp4",
-  mov: "video/quicktime",
-  mp3: "audio/mpeg",
-  wav: "audio/wav",
-  pdf: "application/pdf",
-  txt: "text/plain",
-  json: "application/json"
-};
-function detectContentType(filePath, content) {
-  if (content.length >= 6) {
-    const head = content.subarray(0, 6).toString("ascii");
-    if (head === "GIF87a" || head === "GIF89a") return "image/gif";
-  }
-  if (content.length >= 12 && content.subarray(4, 8).toString("ascii") === "ftyp") {
-    return "video/mp4";
-  }
-  for (const { contentType, prefix } of MAGIC_NUMBERS) {
-    if (matchesPrefix(content, prefix)) {
-      if (contentType === "image/webp") {
-        const formatId = content.subarray(8, 12).toString("ascii");
-        if (formatId === "WEBP") return "image/webp";
-        if (formatId === "WAVE") return "audio/wav";
-        break;
-      }
-      return contentType;
-    }
-  }
-  const ext = filePath.toLowerCase().split(".").pop();
-  if (ext && EXTENSION_FALLBACK[ext]) {
-    return EXTENSION_FALLBACK[ext];
-  }
-  return "application/octet-stream";
-}
-function matchesPrefix(content, prefix) {
-  if (content.length < prefix.length) return false;
-  for (let i = 0; i < prefix.length; i++) {
-    if (content[i] !== prefix[i]) return false;
-  }
-  return true;
-}
 
 // src/commands/generate/internal.ts
 async function buildGenerateClient(opts) {
@@ -1902,37 +1940,19 @@ function isUrlLike(value) {
   return value.startsWith("http://") || value.startsWith("https://");
 }
 
-// src/commands/generate/get.ts
-async function generateGet(opts) {
-  const client = opts.client ?? await buildGenerateClient(opts);
-  return client.request({
-    method: "GET",
-    path: `/jobs/${encodeURIComponent(opts.jobId)}`,
-    query: opts.waitSeconds && opts.waitSeconds > 0 ? { wait: opts.waitSeconds } : void 0,
-    responseSchema: GenerationResultSchema,
-    signal: opts.signal
-  });
-}
-
 // src/commands/generate/wait.ts
 var DEFAULT_WAIT_TIMEOUT_SECONDS = 120;
 var SERVER_LONG_POLL_SECONDS = 30;
 async function generateWait(opts) {
   const client = opts.client ?? await buildGenerateClient(opts);
-  const timeoutSeconds = opts.timeoutSeconds ?? DEFAULT_WAIT_TIMEOUT_SECONDS;
-  return longPoll({
-    // Forward the iteration signal so the in-flight server hold is aborted
-    // as soon as the overall deadline expires — otherwise `--timeout 1` would
-    // still block for the full 30s server long-poll round.
-    fetcher: (args) => generateGet({
-      jobId: opts.jobId,
-      waitSeconds: SERVER_LONG_POLL_SECONDS,
-      client,
-      signal: args?.signal
-    }),
-    isTerminal: (r) => isTerminalStatus(r.status),
-    timeoutMs: timeoutSeconds * 1e3,
-    signal: opts.signal
+  return waitForGeneration({
+    client,
+    jobId: opts.jobId,
+    timeoutMs: (opts.timeoutSeconds ?? DEFAULT_WAIT_TIMEOUT_SECONDS) * 1e3,
+    serverWaitSeconds: SERVER_LONG_POLL_SECONDS,
+    signal: opts.signal,
+    resultSchema: GenerationResultSchema,
+    isTerminal: (r) => isTerminalStatus(r.status)
   });
 }
 
@@ -1950,22 +1970,18 @@ async function generateCreate(opts) {
     signal: opts.signal
   });
   const body = buildRequestBody({ ...opts, referenceImages });
-  const created = await client.request({
-    method: "POST",
-    path: "/jobs",
-    body,
-    responseSchema: GenerateCreateResponseSchema,
-    signal: opts.signal
-  });
-  const wait = opts.wait ?? true;
-  if (!wait) {
-    return projectCreateToResult(created, opts.modelSlug);
-  }
-  return generateWait({
-    jobId: created.jobId,
-    timeoutSeconds: opts.timeoutSeconds ?? DEFAULT_WAIT_TIMEOUT_SECONDS,
+  return createGeneration({
     client,
-    signal: opts.signal
+    body,
+    modelSlug: opts.modelSlug,
+    wait: opts.wait ?? true,
+    timeoutMs: (opts.timeoutSeconds ?? DEFAULT_WAIT_TIMEOUT_SECONDS) * 1e3,
+    serverWaitSeconds: SERVER_LONG_POLL_SECONDS,
+    signal: opts.signal,
+    createSchema: GenerateCreateResponseSchema,
+    resultSchema: GenerationResultSchema,
+    isTerminal: (r) => isTerminalStatus(r.status),
+    projectCreated: projectCreateToResult
   });
 }
 async function resolveReferenceImages(args) {
@@ -2048,6 +2064,18 @@ function projectCreateToResult(response, modelSlug) {
   };
 }
 
+// src/commands/generate/get.ts
+async function generateGet(opts) {
+  const client = opts.client ?? await buildGenerateClient(opts);
+  return client.request({
+    method: "GET",
+    path: `/jobs/${encodeURIComponent(opts.jobId)}`,
+    query: opts.waitSeconds && opts.waitSeconds > 0 ? { wait: opts.waitSeconds } : void 0,
+    responseSchema: GenerationResultSchema,
+    signal: opts.signal
+  });
+}
+
 // src/cli/args.ts
 var ArgError = class extends Error {
   constructor(message) {